chrome/browser/media_galleries/media_galleries_preferences_unittest.cc

   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 // MediaGalleriesPreferences unit tests.
   6
   7 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
   8
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/command_line.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/path_service.h"
  16 #include "base/prefs/scoped_user_pref_update.h"
  17 #include "base/run_loop.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/extensions/test_extension_system.h"
  21 #include "chrome/browser/media_galleries/media_file_system_registry.h"
  22 #include "chrome/browser/media_galleries/media_galleries_test_util.h"
  23 #include "chrome/common/chrome_paths.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "chrome/grit/generated_resources.h"
  26 #include "chrome/test/base/testing_profile.h"
  27 #include "components/storage_monitor/media_storage_util.h"
  28 #include "components/storage_monitor/storage_monitor.h"
  29 #include "components/storage_monitor/test_storage_monitor.h"
  30 #include "content/public/test/test_browser_thread_bundle.h"
  31 #include "extensions/browser/extension_system.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/manifest_handlers/background_info.h"
  34 #include "extensions/common/permissions/media_galleries_permission.h"
  35 #include "sync/api/string_ordinal.h"
  36 #include "testing/gtest/include/gtest/gtest.h"
  37 #include "ui/base/l10n/l10n_util.h"
  38
  39 #if defined(OS_CHROMEOS)
  40 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
  41 #include "chrome/browser/chromeos/settings/cros_settings.h"
  42 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  43 #endif
  44
  45 using base::ASCIIToUTF16;
  46 using storage_monitor::MediaStorageUtil;
  47 using storage_monitor::StorageInfo;
  48 using storage_monitor::TestStorageMonitor;
  49
  50 namespace {
  51
  52 class MockGalleryChangeObserver
  53     : public MediaGalleriesPreferences::GalleryChangeObserver {
  54  public:
  55   explicit MockGalleryChangeObserver(MediaGalleriesPreferences* pref)
  56       : pref_(pref),
  57         notifications_(0) {}
  58   virtual ~MockGalleryChangeObserver() {}
  59
  60   int notifications() const { return notifications_;}
  61
  62  private:
  63   // MediaGalleriesPreferences::GalleryChangeObserver implementation.
  64   virtual void OnPermissionAdded(MediaGalleriesPreferences* pref,
  65                                  const std::string& extension_id,
  66                                  MediaGalleryPrefId pref_id) override {
  67     EXPECT_EQ(pref_, pref);
  68     ++notifications_;
  69   }
  70
  71   virtual void OnPermissionRemoved(MediaGalleriesPreferences* pref,
  72                                    const std::string& extension_id,
  73                                    MediaGalleryPrefId pref_id) override {
  74     EXPECT_EQ(pref_, pref);
  75     ++notifications_;
  76   }
  77
  78   virtual void OnGalleryAdded(MediaGalleriesPreferences* pref,
  79                               MediaGalleryPrefId pref_id) override {
  80     EXPECT_EQ(pref_, pref);
  81     ++notifications_;
  82   }
  83
  84   virtual void OnGalleryRemoved(MediaGalleriesPreferences* pref,
  85                                 MediaGalleryPrefId pref_id) override {
  86     EXPECT_EQ(pref_, pref);
  87     ++notifications_;
  88   }
  89
  90   virtual void OnGalleryInfoUpdated(MediaGalleriesPreferences* pref,
  91                                     MediaGalleryPrefId pref_id) override {
  92     EXPECT_EQ(pref_, pref);
  93     ++notifications_;
  94   }
  95
  96   MediaGalleriesPreferences* pref_;
  97   int notifications_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(MockGalleryChangeObserver);
 100 };
 101
 102 }  // namespace
 103
 104 class MediaGalleriesPreferencesTest : public testing::Test {
 105  public:
 106   typedef std::map<std::string /*device id*/, MediaGalleryPrefIdSet>
 107       DeviceIdPrefIdsMap;
 108
 109   MediaGalleriesPreferencesTest()
 110       : profile_(new TestingProfile()),
 111         default_galleries_count_(0) {
 112   }
 113
 114   virtual ~MediaGalleriesPreferencesTest() {
 115   }
 116
 117   virtual void SetUp() override {
 118     ASSERT_TRUE(TestStorageMonitor::CreateAndInstall());
 119
 120     extensions::TestExtensionSystem* extension_system(
 121         static_cast<extensions::TestExtensionSystem*>(
 122             extensions::ExtensionSystem::Get(profile_.get())));
 123     extension_system->CreateExtensionService(
 124         CommandLine::ForCurrentProcess(), base::FilePath(), false);
 125
 126     ReinitPrefsAndExpectations();
 127
 128     const MediaGalleriesPrefInfoMap& known_galleries =
 129         gallery_prefs_->known_galleries();
 130     if (!known_galleries.empty()) {
 131       ASSERT_EQ(3U, known_galleries.size());
 132     }
 133
 134     std::vector<std::string> all_permissions;
 135     all_permissions.push_back(
 136         extensions::MediaGalleriesPermission::kReadPermission);
 137     all_permissions.push_back(
 138         extensions::MediaGalleriesPermission::kAllAutoDetectedPermission);
 139     std::vector<std::string> read_permissions;
 140     read_permissions.push_back(
 141         extensions::MediaGalleriesPermission::kReadPermission);
 142
 143     all_permission_extension =
 144         AddMediaGalleriesApp("all", all_permissions, profile_.get());
 145     regular_permission_extension =
 146         AddMediaGalleriesApp("regular", read_permissions, profile_.get());
 147     no_permissions_extension =
 148         AddMediaGalleriesApp("no", read_permissions, profile_.get());
 149   }
 150
 151   virtual void TearDown() override {
 152     Verify();
 153     TestStorageMonitor::Destroy();
 154   }
 155
 156   void ChangeMediaPathOverrides() {
 157     mock_gallery_locations_.ChangeMediaPathOverrides();
 158   }
 159
 160   void ReinitPrefsAndExpectations() {
 161     gallery_prefs_.reset(new MediaGalleriesPreferences(profile_.get()));
 162     base::RunLoop loop;
 163     gallery_prefs_->EnsureInitialized(loop.QuitClosure());
 164     loop.Run();
 165
 166     // Load the default galleries into the expectations.
 167     const MediaGalleriesPrefInfoMap& known_galleries =
 168         gallery_prefs_->known_galleries();
 169     if (!known_galleries.empty()) {
 170       default_galleries_count_ = 3;
 171       MediaGalleriesPrefInfoMap::const_iterator it;
 172       for (it = known_galleries.begin(); it != known_galleries.end(); ++it) {
 173         expected_galleries_[it->first] = it->second;
 174         if (it->second.type == MediaGalleryPrefInfo::kAutoDetected)
 175           expected_galleries_for_all.insert(it->first);
 176       }
 177     }
 178   }
 179
 180   void RemovePersistedDefaultGalleryValues() {
 181     PrefService* prefs = profile_->GetPrefs();
 182     scoped_ptr<ListPrefUpdate> update(new ListPrefUpdate(
 183         prefs, prefs::kMediaGalleriesRememberedGalleries));
 184     base::ListValue* list = update->Get();
 185
 186     for (base::ListValue::iterator iter = list->begin();
 187          iter != list->end();
 188          ++iter) {
 189       base::DictionaryValue* dict;
 190
 191       if ((*iter)->GetAsDictionary(&dict)) {
 192         // Setting the prefs version to 2 which is the version before
 193         // default_gallery_type was added.
 194         dict->SetInteger(kMediaGalleriesPrefsVersionKey, 2);
 195         dict->Remove(kMediaGalleriesDefaultGalleryTypeKey, NULL);
 196       }
 197     }
 198     update.reset();
 199   }
 200
 201   void Verify() {
 202     const MediaGalleriesPrefInfoMap& known_galleries =
 203         gallery_prefs_->known_galleries();
 204     EXPECT_EQ(expected_galleries_.size(), known_galleries.size());
 205     for (MediaGalleriesPrefInfoMap::const_iterator it = known_galleries.begin();
 206          it != known_galleries.end();
 207          ++it) {
 208       VerifyGalleryInfo(it->second, it->first);
 209       if (it->second.type != MediaGalleryPrefInfo::kAutoDetected &&
 210           it->second.type != MediaGalleryPrefInfo::kBlackListed) {
 211         if (!ContainsKey(expected_galleries_for_all, it->first) &&
 212             !ContainsKey(expected_galleries_for_regular, it->first)) {
 213           EXPECT_FALSE(gallery_prefs_->NonAutoGalleryHasPermission(it->first));
 214         } else {
 215           EXPECT_TRUE(gallery_prefs_->NonAutoGalleryHasPermission(it->first));
 216         }
 217       }
 218     }
 219
 220     for (DeviceIdPrefIdsMap::const_iterator it = expected_device_map.begin();
 221          it != expected_device_map.end();
 222          ++it) {
 223       MediaGalleryPrefIdSet actual_id_set =
 224           gallery_prefs_->LookUpGalleriesByDeviceId(it->first);
 225       EXPECT_EQ(it->second, actual_id_set);
 226     }
 227
 228     std::set<MediaGalleryPrefId> galleries_for_all =
 229         gallery_prefs_->GalleriesForExtension(*all_permission_extension.get());
 230     EXPECT_EQ(expected_galleries_for_all, galleries_for_all);
 231
 232     std::set<MediaGalleryPrefId> galleries_for_regular =
 233         gallery_prefs_->GalleriesForExtension(
 234             *regular_permission_extension.get());
 235     EXPECT_EQ(expected_galleries_for_regular, galleries_for_regular);
 236
 237     std::set<MediaGalleryPrefId> galleries_for_no =
 238         gallery_prefs_->GalleriesForExtension(*no_permissions_extension.get());
 239     EXPECT_EQ(0U, galleries_for_no.size());
 240   }
 241
 242   void VerifyGalleryInfo(const MediaGalleryPrefInfo& actual,
 243                          MediaGalleryPrefId expected_id) const {
 244     MediaGalleriesPrefInfoMap::const_iterator in_expectation =
 245       expected_galleries_.find(expected_id);
 246     ASSERT_FALSE(in_expectation == expected_galleries_.end())  << expected_id;
 247     EXPECT_EQ(in_expectation->second.pref_id, actual.pref_id);
 248     EXPECT_EQ(in_expectation->second.display_name, actual.display_name);
 249     EXPECT_EQ(in_expectation->second.device_id, actual.device_id);
 250     EXPECT_EQ(in_expectation->second.path.value(), actual.path.value());
 251     EXPECT_EQ(in_expectation->second.type, actual.type);
 252     EXPECT_EQ(in_expectation->second.audio_count, actual.audio_count);
 253     EXPECT_EQ(in_expectation->second.image_count, actual.image_count);
 254     EXPECT_EQ(in_expectation->second.video_count, actual.video_count);
 255     EXPECT_EQ(
 256         in_expectation->second.default_gallery_type,
 257         actual.default_gallery_type);
 258   }
 259
 260   MediaGalleriesPreferences* gallery_prefs() {
 261     return gallery_prefs_.get();
 262   }
 263
 264   uint64 default_galleries_count() {
 265     return default_galleries_count_;
 266   }
 267
 268   void AddGalleryExpectation(MediaGalleryPrefId id, base::string16 display_name,
 269                              std::string device_id,
 270                              base::FilePath relative_path,
 271                              MediaGalleryPrefInfo::Type type) {
 272     expected_galleries_[id].pref_id = id;
 273     expected_galleries_[id].display_name = display_name;
 274     expected_galleries_[id].device_id = device_id;
 275     expected_galleries_[id].path = relative_path.NormalizePathSeparators();
 276     expected_galleries_[id].type = type;
 277
 278     if (type == MediaGalleryPrefInfo::kAutoDetected)
 279       expected_galleries_for_all.insert(id);
 280
 281     expected_device_map[device_id].insert(id);
 282   }
 283
 284   void AddScanResultExpectation(MediaGalleryPrefId id,
 285                                 base::string16 display_name,
 286                                 std::string device_id,
 287                                 base::FilePath relative_path,
 288                                 int audio_count,
 289                                 int image_count,
 290                                 int video_count) {
 291     AddGalleryExpectation(id, display_name, device_id, relative_path,
 292                           MediaGalleryPrefInfo::kScanResult);
 293     expected_galleries_[id].audio_count = audio_count;
 294     expected_galleries_[id].image_count = image_count;
 295     expected_galleries_[id].video_count = video_count;
 296   }
 297
 298   MediaGalleryPrefId AddGalleryWithNameV0(const std::string& device_id,
 299                                           const base::string16& display_name,
 300                                           const base::FilePath& relative_path,
 301                                           bool user_added) {
 302     MediaGalleryPrefInfo::Type type =
 303         user_added ? MediaGalleryPrefInfo::kUserAdded
 304                    : MediaGalleryPrefInfo::kAutoDetected;
 305     return gallery_prefs()->AddOrUpdateGalleryInternal(
 306         device_id, display_name, relative_path, type,
 307         base::string16(), base::string16(), base::string16(), 0, base::Time(),
 308         false, 0, 0, 0, 0, MediaGalleryPrefInfo::kNotDefault);
 309   }
 310
 311   MediaGalleryPrefId AddGalleryWithNameV1(const std::string& device_id,
 312                                           const base::string16& display_name,
 313                                           const base::FilePath& relative_path,
 314                                           bool user_added) {
 315     MediaGalleryPrefInfo::Type type =
 316         user_added ? MediaGalleryPrefInfo::kUserAdded
 317                    : MediaGalleryPrefInfo::kAutoDetected;
 318     return gallery_prefs()->AddOrUpdateGalleryInternal(
 319         device_id, display_name, relative_path, type,
 320         base::string16(), base::string16(), base::string16(), 0, base::Time(),
 321         false, 0, 0, 0, 1, MediaGalleryPrefInfo::kNotDefault);
 322   }
 323
 324   MediaGalleryPrefId AddGalleryWithNameV2(const std::string& device_id,
 325                                           const base::string16& display_name,
 326                                           const base::FilePath& relative_path,
 327                                           MediaGalleryPrefInfo::Type type) {
 328     return gallery_prefs()->AddOrUpdateGalleryInternal(
 329         device_id, display_name, relative_path, type,
 330         base::string16(), base::string16(), base::string16(), 0, base::Time(),
 331         false, 0, 0, 0, 2, MediaGalleryPrefInfo::kNotDefault);
 332   }
 333
 334   MediaGalleryPrefId AddFixedGalleryWithExepectation(
 335       const std::string& path_name, const std::string& name,
 336       MediaGalleryPrefInfo::Type type) {
 337     base::FilePath path = MakeMediaGalleriesTestingPath(path_name);
 338     StorageInfo info;
 339     base::FilePath relative_path;
 340     MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 341     base::string16 gallery_name = base::ASCIIToUTF16(name);
 342     MediaGalleryPrefId id = AddGalleryWithNameV2(info.device_id(), gallery_name,
 343                                                 relative_path, type);
 344     AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 345                           type);
 346     Verify();
 347     return id;
 348   }
 349
 350   bool UpdateDeviceIDForSingletonType(const std::string& device_id) {
 351     return gallery_prefs()->UpdateDeviceIDForSingletonType(device_id);
 352   }
 353
 354   scoped_refptr<extensions::Extension> all_permission_extension;
 355   scoped_refptr<extensions::Extension> regular_permission_extension;
 356   scoped_refptr<extensions::Extension> no_permissions_extension;
 357
 358   std::set<MediaGalleryPrefId> expected_galleries_for_all;
 359   std::set<MediaGalleryPrefId> expected_galleries_for_regular;
 360
 361   DeviceIdPrefIdsMap expected_device_map;
 362
 363   MediaGalleriesPrefInfoMap expected_galleries_;
 364
 365  private:
 366   // Needed for extension service & friends to work.
 367   content::TestBrowserThreadBundle thread_bundle_;
 368
 369   EnsureMediaDirectoriesExists mock_gallery_locations_;
 370
 371 #if defined(OS_CHROMEOS)
 372   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 373   chromeos::ScopedTestCrosSettings test_cros_settings_;
 374   chromeos::ScopedTestUserManager test_user_manager_;
 375 #endif
 376
 377   TestStorageMonitor monitor_;
 378   scoped_ptr<TestingProfile> profile_;
 379   scoped_ptr<MediaGalleriesPreferences> gallery_prefs_;
 380
 381   uint64 default_galleries_count_;
 382
 383   DISALLOW_COPY_AND_ASSIGN(MediaGalleriesPreferencesTest);
 384 };
 385
 386 TEST_F(MediaGalleriesPreferencesTest, GalleryManagement) {
 387   MediaGalleryPrefId auto_id, user_added_id, scan_id, id;
 388   base::FilePath path;
 389   base::FilePath relative_path;
 390   Verify();
 391
 392   // Add a new auto detected gallery.
 393   path = MakeMediaGalleriesTestingPath("new_auto");
 394   StorageInfo info;
 395   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 396   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
 397   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 398                             MediaGalleryPrefInfo::kAutoDetected);
 399   EXPECT_EQ(default_galleries_count() + 1UL, id);
 400   auto_id = id;
 401   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 402                         MediaGalleryPrefInfo::kAutoDetected);
 403   Verify();
 404
 405   // Add it as other types, nothing should happen.
 406   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 407                             MediaGalleryPrefInfo::kUserAdded);
 408   EXPECT_EQ(auto_id, id);
 409   Verify();
 410   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 411                             MediaGalleryPrefInfo::kAutoDetected);
 412   EXPECT_EQ(auto_id, id);
 413   Verify();
 414   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 415                             MediaGalleryPrefInfo::kScanResult);
 416   EXPECT_EQ(auto_id, id);
 417
 418   // Add a new user added gallery.
 419   path = MakeMediaGalleriesTestingPath("new_user");
 420   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 421   gallery_name = base::ASCIIToUTF16("NewUserGallery");
 422   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 423                             MediaGalleryPrefInfo::kUserAdded);
 424   EXPECT_EQ(default_galleries_count() + 2UL, id);
 425   user_added_id = id;
 426   const std::string user_added_device_id = info.device_id();
 427   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 428                         MediaGalleryPrefInfo::kUserAdded);
 429   Verify();
 430
 431   // Add it as other types, nothing should happen.
 432   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 433                             MediaGalleryPrefInfo::kUserAdded);
 434   EXPECT_EQ(user_added_id, id);
 435   Verify();
 436   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 437                             MediaGalleryPrefInfo::kAutoDetected);
 438   EXPECT_EQ(user_added_id, id);
 439   Verify();
 440   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 441                             MediaGalleryPrefInfo::kScanResult);
 442   EXPECT_EQ(user_added_id, id);
 443   Verify();
 444
 445   // Add a new scan result gallery.
 446   path = MakeMediaGalleriesTestingPath("new_scan");
 447   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 448   gallery_name = base::ASCIIToUTF16("NewScanGallery");
 449   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 450                             MediaGalleryPrefInfo::kScanResult);
 451   EXPECT_EQ(default_galleries_count() + 3UL, id);
 452   scan_id = id;
 453   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 454                         MediaGalleryPrefInfo::kScanResult);
 455   Verify();
 456
 457   // Add it as other types, nothing should happen.
 458   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 459                             MediaGalleryPrefInfo::kUserAdded);
 460   EXPECT_EQ(scan_id, id);
 461   Verify();
 462   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 463                             MediaGalleryPrefInfo::kAutoDetected);
 464   EXPECT_EQ(scan_id, id);
 465   Verify();
 466   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 467                             MediaGalleryPrefInfo::kScanResult);
 468   EXPECT_EQ(scan_id, id);
 469   Verify();
 470
 471   // Lookup some galleries.
 472   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 473       MakeMediaGalleriesTestingPath("new_auto"), NULL));
 474   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 475       MakeMediaGalleriesTestingPath("new_user"), NULL));
 476   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 477       MakeMediaGalleriesTestingPath("new_scan"), NULL));
 478   EXPECT_FALSE(gallery_prefs()->LookUpGalleryByPath(
 479       MakeMediaGalleriesTestingPath("other"), NULL));
 480
 481   // Check that we always get the gallery info.
 482   MediaGalleryPrefInfo gallery_info;
 483   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 484       MakeMediaGalleriesTestingPath("new_auto"), &gallery_info));
 485   VerifyGalleryInfo(gallery_info, auto_id);
 486   EXPECT_FALSE(gallery_info.volume_metadata_valid);
 487   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 488       MakeMediaGalleriesTestingPath("new_user"), &gallery_info));
 489   VerifyGalleryInfo(gallery_info, user_added_id);
 490   EXPECT_FALSE(gallery_info.volume_metadata_valid);
 491   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 492       MakeMediaGalleriesTestingPath("new_scan"), &gallery_info));
 493   VerifyGalleryInfo(gallery_info, scan_id);
 494   EXPECT_FALSE(gallery_info.volume_metadata_valid);
 495
 496   path = MakeMediaGalleriesTestingPath("other");
 497   EXPECT_FALSE(gallery_prefs()->LookUpGalleryByPath(path, &gallery_info));
 498   EXPECT_EQ(kInvalidMediaGalleryPrefId, gallery_info.pref_id);
 499
 500   StorageInfo other_info;
 501   MediaStorageUtil::GetDeviceInfoFromPath(path, &other_info, &relative_path);
 502   EXPECT_EQ(other_info.device_id(), gallery_info.device_id);
 503   EXPECT_EQ(relative_path.value(), gallery_info.path.value());
 504
 505   // Remove an auto added gallery (i.e. make it blacklisted).
 506   gallery_prefs()->ForgetGalleryById(auto_id);
 507   expected_galleries_[auto_id].type = MediaGalleryPrefInfo::kBlackListed;
 508   expected_galleries_for_all.erase(auto_id);
 509   Verify();
 510
 511   // Remove a scan result (i.e. make it blacklisted).
 512   gallery_prefs()->ForgetGalleryById(scan_id);
 513   expected_galleries_[scan_id].type = MediaGalleryPrefInfo::kRemovedScan;
 514   Verify();
 515
 516   // Remove a user added gallery and it should go away.
 517   gallery_prefs()->ForgetGalleryById(user_added_id);
 518   expected_galleries_.erase(user_added_id);
 519   expected_device_map[user_added_device_id].erase(user_added_id);
 520   Verify();
 521 }
 522
 523 TEST_F(MediaGalleriesPreferencesTest, ForgetAndErase) {
 524   MediaGalleryPrefId user_erase =
 525       AddFixedGalleryWithExepectation("user_erase", "UserErase",
 526                                       MediaGalleryPrefInfo::kUserAdded);
 527   EXPECT_EQ(default_galleries_count() + 1UL, user_erase);
 528   MediaGalleryPrefId user_forget =
 529       AddFixedGalleryWithExepectation("user_forget", "UserForget",
 530                                       MediaGalleryPrefInfo::kUserAdded);
 531   EXPECT_EQ(default_galleries_count() + 2UL, user_forget);
 532
 533   MediaGalleryPrefId auto_erase =
 534       AddFixedGalleryWithExepectation("auto_erase", "AutoErase",
 535                                       MediaGalleryPrefInfo::kAutoDetected);
 536   EXPECT_EQ(default_galleries_count() + 3UL, auto_erase);
 537   MediaGalleryPrefId auto_forget =
 538       AddFixedGalleryWithExepectation("auto_forget", "AutoForget",
 539                                       MediaGalleryPrefInfo::kAutoDetected);
 540   EXPECT_EQ(default_galleries_count() + 4UL, auto_forget);
 541
 542   MediaGalleryPrefId scan_erase =
 543       AddFixedGalleryWithExepectation("scan_erase", "ScanErase",
 544                                       MediaGalleryPrefInfo::kScanResult);
 545   EXPECT_EQ(default_galleries_count() + 5UL, scan_erase);
 546   MediaGalleryPrefId scan_forget =
 547       AddFixedGalleryWithExepectation("scan_forget", "ScanForget",
 548                                       MediaGalleryPrefInfo::kScanResult);
 549   EXPECT_EQ(default_galleries_count() + 6UL, scan_forget);
 550
 551   Verify();
 552   std::string device_id;
 553
 554   gallery_prefs()->ForgetGalleryById(user_forget);
 555   device_id = expected_galleries_[user_forget].device_id;
 556   expected_galleries_.erase(user_forget);
 557   expected_device_map[device_id].erase(user_forget);
 558   Verify();
 559
 560   gallery_prefs()->ForgetGalleryById(auto_forget);
 561   expected_galleries_[auto_forget].type = MediaGalleryPrefInfo::kBlackListed;
 562   expected_galleries_for_all.erase(auto_forget);
 563   Verify();
 564
 565   gallery_prefs()->ForgetGalleryById(scan_forget);
 566   expected_galleries_[scan_forget].type = MediaGalleryPrefInfo::kRemovedScan;
 567   Verify();
 568
 569   gallery_prefs()->EraseGalleryById(user_erase);
 570   device_id = expected_galleries_[user_erase].device_id;
 571   expected_galleries_.erase(user_erase);
 572   expected_device_map[device_id].erase(user_erase);
 573   Verify();
 574
 575   gallery_prefs()->EraseGalleryById(auto_erase);
 576   device_id = expected_galleries_[auto_erase].device_id;
 577   expected_galleries_.erase(auto_erase);
 578   expected_device_map[device_id].erase(auto_erase);
 579   expected_galleries_for_all.erase(auto_erase);
 580   Verify();
 581
 582   gallery_prefs()->EraseGalleryById(scan_erase);
 583   device_id = expected_galleries_[scan_erase].device_id;
 584   expected_galleries_.erase(scan_erase);
 585   expected_device_map[device_id].erase(scan_erase);
 586   Verify();
 587
 588   // Also erase the previously forgetten ones to check erasing blacklisted ones.
 589   gallery_prefs()->EraseGalleryById(auto_forget);
 590   device_id = expected_galleries_[auto_forget].device_id;
 591   expected_galleries_.erase(auto_forget);
 592   expected_device_map[device_id].erase(auto_forget);
 593   Verify();
 594
 595   gallery_prefs()->EraseGalleryById(scan_forget);
 596   device_id = expected_galleries_[scan_forget].device_id;
 597   expected_galleries_.erase(scan_forget);
 598   expected_device_map[device_id].erase(scan_forget);
 599   Verify();
 600 }
 601
 602 TEST_F(MediaGalleriesPreferencesTest, AddGalleryWithVolumeMetadata) {
 603   MediaGalleryPrefId id;
 604   StorageInfo info;
 605   base::FilePath path;
 606   base::FilePath relative_path;
 607   base::Time now = base::Time::Now();
 608   Verify();
 609
 610   // Add a new auto detected gallery.
 611   path = MakeMediaGalleriesTestingPath("new_auto");
 612   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 613   id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
 614                                    MediaGalleryPrefInfo::kAutoDetected,
 615                                    ASCIIToUTF16("volume label"),
 616                                    ASCIIToUTF16("vendor name"),
 617                                    ASCIIToUTF16("model name"),
 618                                    1000000ULL, now, 0, 0, 0);
 619   EXPECT_EQ(default_galleries_count() + 1UL, id);
 620   AddGalleryExpectation(id, base::string16(), info.device_id(), relative_path,
 621                         MediaGalleryPrefInfo::kAutoDetected);
 622   Verify();
 623
 624   MediaGalleryPrefInfo gallery_info;
 625   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(
 626       MakeMediaGalleriesTestingPath("new_auto"), &gallery_info));
 627   EXPECT_TRUE(gallery_info.volume_metadata_valid);
 628   EXPECT_EQ(ASCIIToUTF16("volume label"), gallery_info.volume_label);
 629   EXPECT_EQ(ASCIIToUTF16("vendor name"), gallery_info.vendor_name);
 630   EXPECT_EQ(ASCIIToUTF16("model name"), gallery_info.model_name);
 631   EXPECT_EQ(1000000ULL, gallery_info.total_size_in_bytes);
 632   // Note: we put the microseconds time into a double, so there'll
 633   // be some possible rounding errors. If it's less than 100, we don't
 634   // care.
 635   EXPECT_LE(std::abs(now.ToInternalValue() -
 636                      gallery_info.last_attach_time.ToInternalValue()),
 637             100);
 638 }
 639
 640 TEST_F(MediaGalleriesPreferencesTest, ReplaceGalleryWithVolumeMetadata) {
 641   MediaGalleryPrefId id, metadata_id;
 642   base::FilePath path;
 643   StorageInfo info;
 644   base::FilePath relative_path;
 645   base::Time now = base::Time::Now();
 646   Verify();
 647
 648   // Add an auto detected gallery in the prefs version 0 format.
 649   path = MakeMediaGalleriesTestingPath("new_auto");
 650   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 651   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
 652   id = AddGalleryWithNameV0(info.device_id(), gallery_name, relative_path,
 653                             false /*auto*/);
 654   EXPECT_EQ(default_galleries_count() + 1UL, id);
 655   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 656                         MediaGalleryPrefInfo::kAutoDetected);
 657   Verify();
 658
 659   metadata_id = gallery_prefs()->AddGallery(info.device_id(),
 660                                             relative_path,
 661                                             MediaGalleryPrefInfo::kAutoDetected,
 662                                             ASCIIToUTF16("volume label"),
 663                                             ASCIIToUTF16("vendor name"),
 664                                             ASCIIToUTF16("model name"),
 665                                             1000000ULL, now, 0, 0, 0);
 666   EXPECT_EQ(id, metadata_id);
 667   AddGalleryExpectation(id, base::string16(), info.device_id(), relative_path,
 668                         MediaGalleryPrefInfo::kAutoDetected);
 669
 670   // Make sure the display_name is set to empty now, as the metadata
 671   // upgrade should set the manual override name empty.
 672   Verify();
 673 }
 674
 675 // Whenever an "AutoDetected" gallery is removed, it is moved to a black listed
 676 // state.  When the gallery is added again, the black listed state is updated
 677 // back to the "AutoDetected" type.
 678 TEST_F(MediaGalleriesPreferencesTest, AutoAddedBlackListing) {
 679   MediaGalleryPrefId auto_id, id;
 680   base::FilePath path;
 681   StorageInfo info;
 682   base::FilePath relative_path;
 683   Verify();
 684
 685   // Add a new auto detect gallery to test with.
 686   path = MakeMediaGalleriesTestingPath("new_auto");
 687   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 688   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
 689   id = AddGalleryWithNameV1(info.device_id(), gallery_name,
 690                             relative_path, false /*auto*/);
 691   EXPECT_EQ(default_galleries_count() + 1UL, id);
 692   auto_id = id;
 693   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 694                         MediaGalleryPrefInfo::kAutoDetected);
 695   Verify();
 696
 697   // Remove an auto added gallery (i.e. make it blacklisted).
 698   gallery_prefs()->ForgetGalleryById(auto_id);
 699   expected_galleries_[auto_id].type = MediaGalleryPrefInfo::kBlackListed;
 700   expected_galleries_for_all.erase(auto_id);
 701   Verify();
 702
 703   // Try adding the gallery again automatically and it should be a no-op.
 704   id = AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
 705                             false /*auto*/);
 706   EXPECT_EQ(auto_id, id);
 707   Verify();
 708
 709   // Add the gallery again as a user action.
 710   id = gallery_prefs()->AddGalleryByPath(path,
 711                                          MediaGalleryPrefInfo::kUserAdded);
 712   EXPECT_EQ(auto_id, id);
 713   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 714                         MediaGalleryPrefInfo::kAutoDetected);
 715   Verify();
 716 }
 717
 718 // Whenever a "ScanResult" gallery is removed, it is moved to a black listed
 719 // state.  When the gallery is added again, the black listed state is updated
 720 // back to the "ScanResult" type.
 721 TEST_F(MediaGalleriesPreferencesTest, ScanResultBlackListing) {
 722   MediaGalleryPrefId scan_id, id;
 723   base::FilePath path;
 724   StorageInfo info;
 725   base::FilePath relative_path;
 726   Verify();
 727
 728   // Add a new scan result gallery to test with.
 729   path = MakeMediaGalleriesTestingPath("new_scan");
 730   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 731   base::string16 gallery_name = base::ASCIIToUTF16("NewScanGallery");
 732   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 733                             MediaGalleryPrefInfo::kScanResult);
 734   EXPECT_EQ(default_galleries_count() + 1UL, id);
 735   scan_id = id;
 736   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 737                         MediaGalleryPrefInfo::kScanResult);
 738   Verify();
 739
 740   // Remove a scan result gallery (i.e. make it blacklisted).
 741   gallery_prefs()->ForgetGalleryById(scan_id);
 742   expected_galleries_[scan_id].type = MediaGalleryPrefInfo::kRemovedScan;
 743   expected_galleries_for_all.erase(scan_id);
 744   Verify();
 745
 746   // Try adding the gallery again as a scan result it should be a no-op.
 747   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 748                             MediaGalleryPrefInfo::kScanResult);
 749   EXPECT_EQ(scan_id, id);
 750   Verify();
 751
 752   // Add the gallery again as a user action.
 753   id = gallery_prefs()->AddGalleryByPath(path,
 754                                          MediaGalleryPrefInfo::kUserAdded);
 755   EXPECT_EQ(scan_id, id);
 756   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 757                         MediaGalleryPrefInfo::kUserAdded);
 758   Verify();
 759 }
 760
 761 TEST_F(MediaGalleriesPreferencesTest, UpdateGalleryNameV2) {
 762   // Add a new auto detect gallery to test with.
 763   base::FilePath path = MakeMediaGalleriesTestingPath("new_auto");
 764   StorageInfo info;
 765   base::FilePath relative_path;
 766   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 767   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
 768   MediaGalleryPrefId id =
 769       AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 770                            MediaGalleryPrefInfo::kAutoDetected);
 771   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 772                         MediaGalleryPrefInfo::kAutoDetected);
 773   Verify();
 774
 775   // Won't override the name -- don't change any expectation.
 776   gallery_name = base::string16();
 777   AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 778                        MediaGalleryPrefInfo::kAutoDetected);
 779   Verify();
 780
 781   gallery_name = base::ASCIIToUTF16("NewName");
 782   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 783                             MediaGalleryPrefInfo::kAutoDetected);
 784   // Note: will really just update the existing expectation.
 785   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 786                         MediaGalleryPrefInfo::kAutoDetected);
 787   Verify();
 788 }
 789
 790 TEST_F(MediaGalleriesPreferencesTest, GalleryPermissions) {
 791   MediaGalleryPrefId auto_id, user_added_id, to_blacklist_id, scan_id,
 792                      to_scan_remove_id, id;
 793   base::FilePath path;
 794   StorageInfo info;
 795   base::FilePath relative_path;
 796   Verify();
 797
 798   // Add some galleries to test with.
 799   path = MakeMediaGalleriesTestingPath("new_user");
 800   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 801   base::string16 gallery_name = base::ASCIIToUTF16("NewUserGallery");
 802   id = AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
 803                             true /*user*/);
 804   EXPECT_EQ(default_galleries_count() + 1UL, id);
 805   user_added_id = id;
 806   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 807                         MediaGalleryPrefInfo::kUserAdded);
 808   Verify();
 809
 810   path = MakeMediaGalleriesTestingPath("new_auto");
 811   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 812   gallery_name = base::ASCIIToUTF16("NewAutoGallery");
 813   id = AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
 814                             false /*auto*/);
 815   EXPECT_EQ(default_galleries_count() + 2UL, id);
 816   auto_id = id;
 817   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 818                         MediaGalleryPrefInfo::kAutoDetected);
 819   Verify();
 820
 821   path = MakeMediaGalleriesTestingPath("to_blacklist");
 822   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 823   gallery_name = base::ASCIIToUTF16("ToBlacklistGallery");
 824   id = AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
 825                             false /*auto*/);
 826   EXPECT_EQ(default_galleries_count() + 3UL, id);
 827   to_blacklist_id = id;
 828   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 829                         MediaGalleryPrefInfo::kAutoDetected);
 830   Verify();
 831
 832   path = MakeMediaGalleriesTestingPath("new_scan");
 833   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 834   gallery_name = base::ASCIIToUTF16("NewScanGallery");
 835   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 836                             MediaGalleryPrefInfo::kScanResult);
 837   EXPECT_EQ(default_galleries_count() + 4UL, id);
 838   scan_id = id;
 839   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 840                         MediaGalleryPrefInfo::kScanResult);
 841   Verify();
 842
 843   path = MakeMediaGalleriesTestingPath("to_scan_remove");
 844   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 845   gallery_name = base::ASCIIToUTF16("ToScanRemoveGallery");
 846   id = AddGalleryWithNameV2(info.device_id(), gallery_name, relative_path,
 847                             MediaGalleryPrefInfo::kScanResult);
 848   EXPECT_EQ(default_galleries_count() + 5UL, id);
 849   to_scan_remove_id = id;
 850   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 851                         MediaGalleryPrefInfo::kScanResult);
 852   Verify();
 853
 854   // Remove permission for all galleries from the all-permission extension.
 855   gallery_prefs()->SetGalleryPermissionForExtension(
 856       *all_permission_extension.get(), auto_id, false);
 857   expected_galleries_for_all.erase(auto_id);
 858   Verify();
 859
 860   gallery_prefs()->SetGalleryPermissionForExtension(
 861       *all_permission_extension.get(), user_added_id, false);
 862   expected_galleries_for_all.erase(user_added_id);
 863   Verify();
 864
 865   gallery_prefs()->SetGalleryPermissionForExtension(
 866       *all_permission_extension.get(), to_blacklist_id, false);
 867   expected_galleries_for_all.erase(to_blacklist_id);
 868   Verify();
 869
 870   gallery_prefs()->SetGalleryPermissionForExtension(
 871       *all_permission_extension.get(), scan_id, false);
 872   expected_galleries_for_all.erase(scan_id);
 873   Verify();
 874
 875   gallery_prefs()->SetGalleryPermissionForExtension(
 876       *all_permission_extension.get(), to_scan_remove_id, false);
 877   expected_galleries_for_all.erase(to_scan_remove_id);
 878   Verify();
 879
 880   // Add permission back for all galleries to the all-permission extension.
 881   gallery_prefs()->SetGalleryPermissionForExtension(
 882       *all_permission_extension.get(), auto_id, true);
 883   expected_galleries_for_all.insert(auto_id);
 884   Verify();
 885
 886   gallery_prefs()->SetGalleryPermissionForExtension(
 887       *all_permission_extension.get(), user_added_id, true);
 888   expected_galleries_for_all.insert(user_added_id);
 889   Verify();
 890
 891   gallery_prefs()->SetGalleryPermissionForExtension(
 892       *all_permission_extension.get(), to_blacklist_id, true);
 893   expected_galleries_for_all.insert(to_blacklist_id);
 894   Verify();
 895
 896   gallery_prefs()->SetGalleryPermissionForExtension(
 897       *all_permission_extension.get(), scan_id, true);
 898   expected_galleries_for_all.insert(scan_id);
 899   Verify();
 900
 901   gallery_prefs()->SetGalleryPermissionForExtension(
 902       *all_permission_extension.get(), to_scan_remove_id, true);
 903   expected_galleries_for_all.insert(to_scan_remove_id);
 904   Verify();
 905
 906   // Add permission for all galleries to the regular permission extension.
 907   gallery_prefs()->SetGalleryPermissionForExtension(
 908       *regular_permission_extension.get(), auto_id, true);
 909   expected_galleries_for_regular.insert(auto_id);
 910   Verify();
 911
 912   gallery_prefs()->SetGalleryPermissionForExtension(
 913       *regular_permission_extension.get(), user_added_id, true);
 914   expected_galleries_for_regular.insert(user_added_id);
 915   Verify();
 916
 917   gallery_prefs()->SetGalleryPermissionForExtension(
 918       *regular_permission_extension.get(), to_blacklist_id, true);
 919   expected_galleries_for_regular.insert(to_blacklist_id);
 920   Verify();
 921
 922   gallery_prefs()->SetGalleryPermissionForExtension(
 923       *regular_permission_extension.get(), scan_id, true);
 924   expected_galleries_for_regular.insert(scan_id);
 925   Verify();
 926
 927   gallery_prefs()->SetGalleryPermissionForExtension(
 928       *regular_permission_extension.get(), to_scan_remove_id, true);
 929   expected_galleries_for_regular.insert(to_scan_remove_id);
 930   Verify();
 931
 932   // Blacklist the to be black listed gallery
 933   gallery_prefs()->ForgetGalleryById(to_blacklist_id);
 934   expected_galleries_[to_blacklist_id].type =
 935       MediaGalleryPrefInfo::kBlackListed;
 936   expected_galleries_for_all.erase(to_blacklist_id);
 937   expected_galleries_for_regular.erase(to_blacklist_id);
 938   Verify();
 939
 940   gallery_prefs()->ForgetGalleryById(to_scan_remove_id);
 941   expected_galleries_[to_scan_remove_id].type =
 942       MediaGalleryPrefInfo::kRemovedScan;
 943   expected_galleries_for_all.erase(to_scan_remove_id);
 944   expected_galleries_for_regular.erase(to_scan_remove_id);
 945   Verify();
 946
 947   // Remove permission for all galleries to the regular permission extension.
 948   gallery_prefs()->SetGalleryPermissionForExtension(
 949       *regular_permission_extension.get(), auto_id, false);
 950   expected_galleries_for_regular.erase(auto_id);
 951   Verify();
 952
 953   gallery_prefs()->SetGalleryPermissionForExtension(
 954       *regular_permission_extension.get(), user_added_id, false);
 955   expected_galleries_for_regular.erase(user_added_id);
 956   Verify();
 957
 958   gallery_prefs()->SetGalleryPermissionForExtension(
 959       *regular_permission_extension.get(), scan_id, false);
 960   expected_galleries_for_regular.erase(scan_id);
 961   Verify();
 962
 963   // Add permission for an invalid gallery id.
 964   gallery_prefs()->SetGalleryPermissionForExtension(
 965       *regular_permission_extension.get(), 9999L, true);
 966   Verify();
 967 }
 968
 969 // What an existing gallery is added again, update the gallery information if
 970 // needed.
 971 TEST_F(MediaGalleriesPreferencesTest, UpdateGalleryDetails) {
 972   MediaGalleryPrefId auto_id, id;
 973   base::FilePath path;
 974   StorageInfo info;
 975   base::FilePath relative_path;
 976   Verify();
 977
 978   // Add a new auto detect gallery to test with.
 979   path = MakeMediaGalleriesTestingPath("new_auto");
 980   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
 981   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
 982   id = AddGalleryWithNameV1(info.device_id(), gallery_name,
 983                             relative_path, false /*auto*/);
 984   EXPECT_EQ(default_galleries_count() + 1UL, id);
 985   auto_id = id;
 986   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 987                         MediaGalleryPrefInfo::kAutoDetected);
 988   Verify();
 989
 990   // Update the device name and add the gallery again.
 991   gallery_name = base::ASCIIToUTF16("AutoGallery2");
 992   id = AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
 993                             false /*auto*/);
 994   EXPECT_EQ(auto_id, id);
 995   AddGalleryExpectation(id, gallery_name, info.device_id(), relative_path,
 996                         MediaGalleryPrefInfo::kAutoDetected);
 997   Verify();
 998 }
 999
1000 TEST_F(MediaGalleriesPreferencesTest, MultipleGalleriesPerDevices) {
1001   base::FilePath path;
1002   StorageInfo info;
1003   base::FilePath relative_path;
1004   Verify();
1005
1006   // Add a regular gallery
1007   path = MakeMediaGalleriesTestingPath("new_user");
1008   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
1009   base::string16 gallery_name = base::ASCIIToUTF16("NewUserGallery");
1010   MediaGalleryPrefId user_added_id =
1011       AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
1012                            true /*user*/);
1013   EXPECT_EQ(default_galleries_count() + 1UL, user_added_id);
1014   AddGalleryExpectation(user_added_id, gallery_name, info.device_id(),
1015                         relative_path, MediaGalleryPrefInfo::kUserAdded);
1016   Verify();
1017
1018   // Find it by device id and fail to find something related.
1019   MediaGalleryPrefIdSet pref_id_set;
1020   pref_id_set = gallery_prefs()->LookUpGalleriesByDeviceId(info.device_id());
1021   EXPECT_EQ(1U, pref_id_set.size());
1022   EXPECT_TRUE(pref_id_set.find(user_added_id) != pref_id_set.end());
1023
1024   MediaStorageUtil::GetDeviceInfoFromPath(
1025       MakeMediaGalleriesTestingPath("new_user/foo"), &info, &relative_path);
1026   pref_id_set = gallery_prefs()->LookUpGalleriesByDeviceId(info.device_id());
1027   EXPECT_EQ(0U, pref_id_set.size());
1028
1029   // Add some galleries on the same device.
1030   relative_path = base::FilePath(FILE_PATH_LITERAL("path1/on/device1"));
1031   gallery_name = base::ASCIIToUTF16("Device1Path1");
1032   std::string device_id = "path:device1";
1033   MediaGalleryPrefId dev1_path1_id = AddGalleryWithNameV1(
1034       device_id, gallery_name, relative_path, true /*user*/);
1035   EXPECT_EQ(default_galleries_count() + 2UL, dev1_path1_id);
1036   AddGalleryExpectation(dev1_path1_id, gallery_name, device_id, relative_path,
1037                         MediaGalleryPrefInfo::kUserAdded);
1038   Verify();
1039
1040   relative_path = base::FilePath(FILE_PATH_LITERAL("path2/on/device1"));
1041   gallery_name = base::ASCIIToUTF16("Device1Path2");
1042   MediaGalleryPrefId dev1_path2_id = AddGalleryWithNameV1(
1043       device_id, gallery_name, relative_path, true /*user*/);
1044   EXPECT_EQ(default_galleries_count() + 3UL, dev1_path2_id);
1045   AddGalleryExpectation(dev1_path2_id, gallery_name, device_id, relative_path,
1046                         MediaGalleryPrefInfo::kUserAdded);
1047   Verify();
1048
1049   relative_path = base::FilePath(FILE_PATH_LITERAL("path1/on/device2"));
1050   gallery_name = base::ASCIIToUTF16("Device2Path1");
1051   device_id = "path:device2";
1052   MediaGalleryPrefId dev2_path1_id = AddGalleryWithNameV1(
1053       device_id, gallery_name, relative_path, true /*user*/);
1054   EXPECT_EQ(default_galleries_count() + 4UL, dev2_path1_id);
1055   AddGalleryExpectation(dev2_path1_id, gallery_name, device_id, relative_path,
1056                         MediaGalleryPrefInfo::kUserAdded);
1057   Verify();
1058
1059   relative_path = base::FilePath(FILE_PATH_LITERAL("path2/on/device2"));
1060   gallery_name = base::ASCIIToUTF16("Device2Path2");
1061   MediaGalleryPrefId dev2_path2_id = AddGalleryWithNameV1(
1062       device_id, gallery_name, relative_path, true /*user*/);
1063   EXPECT_EQ(default_galleries_count() + 5UL, dev2_path2_id);
1064   AddGalleryExpectation(dev2_path2_id, gallery_name, device_id, relative_path,
1065                         MediaGalleryPrefInfo::kUserAdded);
1066   Verify();
1067
1068   // Check that adding one of them again works as expected.
1069   MediaGalleryPrefId id = AddGalleryWithNameV1(
1070       device_id, gallery_name, relative_path, true /*user*/);
1071   EXPECT_EQ(dev2_path2_id, id);
1072   Verify();
1073 }
1074
1075 TEST_F(MediaGalleriesPreferencesTest, GalleryChangeObserver) {
1076   // Start with one observer.
1077   MockGalleryChangeObserver observer1(gallery_prefs());
1078   gallery_prefs()->AddGalleryChangeObserver(&observer1);
1079
1080   // Add a new auto detected gallery.
1081   base::FilePath path = MakeMediaGalleriesTestingPath("new_auto");
1082   StorageInfo info;
1083   base::FilePath relative_path;
1084   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
1085   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
1086   MediaGalleryPrefId auto_id = AddGalleryWithNameV1(
1087       info.device_id(), gallery_name, relative_path, false /*auto*/);
1088   EXPECT_EQ(default_galleries_count() + 1UL, auto_id);
1089   AddGalleryExpectation(auto_id, gallery_name, info.device_id(),
1090                         relative_path, MediaGalleryPrefInfo::kAutoDetected);
1091   EXPECT_EQ(1, observer1.notifications());
1092
1093   // Add a second observer.
1094   MockGalleryChangeObserver observer2(gallery_prefs());
1095   gallery_prefs()->AddGalleryChangeObserver(&observer2);
1096
1097   // Add a new user added gallery.
1098   path = MakeMediaGalleriesTestingPath("new_user");
1099   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
1100   gallery_name = base::ASCIIToUTF16("NewUserGallery");
1101   MediaGalleryPrefId user_added_id =
1102       AddGalleryWithNameV1(info.device_id(), gallery_name, relative_path,
1103                            true /*user*/);
1104   AddGalleryExpectation(user_added_id, gallery_name, info.device_id(),
1105                         relative_path, MediaGalleryPrefInfo::kUserAdded);
1106   EXPECT_EQ(default_galleries_count() + 2UL, user_added_id);
1107   EXPECT_EQ(2, observer1.notifications());
1108   EXPECT_EQ(1, observer2.notifications());
1109
1110   // Remove the first observer.
1111   gallery_prefs()->RemoveGalleryChangeObserver(&observer1);
1112
1113   // Remove an auto added gallery (i.e. make it blacklisted).
1114   gallery_prefs()->ForgetGalleryById(auto_id);
1115   expected_galleries_[auto_id].type = MediaGalleryPrefInfo::kBlackListed;
1116   expected_galleries_for_all.erase(auto_id);
1117
1118   EXPECT_EQ(2, observer1.notifications());
1119   EXPECT_EQ(2, observer2.notifications());
1120
1121   // Remove a user added gallery and it should go away.
1122   gallery_prefs()->ForgetGalleryById(user_added_id);
1123   expected_galleries_.erase(user_added_id);
1124   expected_device_map[info.device_id()].erase(user_added_id);
1125
1126   EXPECT_EQ(2, observer1.notifications());
1127   EXPECT_EQ(3, observer2.notifications());
1128 }
1129
1130 TEST_F(MediaGalleriesPreferencesTest, UpdateSingletonDeviceIdType) {
1131   MediaGalleryPrefId id;
1132   base::FilePath path;
1133   Verify();
1134
1135   // Add a new auto detect gallery to test with.
1136   path = MakeMediaGalleriesTestingPath("new_auto");
1137   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
1138   std::string device_id = StorageInfo::MakeDeviceId(StorageInfo::ITUNES,
1139                                                     path.AsUTF8Unsafe());
1140   id = AddGalleryWithNameV2(device_id, gallery_name, base::FilePath(),
1141                             MediaGalleryPrefInfo::kAutoDetected);
1142   EXPECT_EQ(default_galleries_count() + 1UL, id);
1143   AddGalleryExpectation(id, gallery_name, device_id, base::FilePath(),
1144                         MediaGalleryPrefInfo::kAutoDetected);
1145   Verify();
1146
1147   // Update the device id.
1148   MockGalleryChangeObserver observer(gallery_prefs());
1149   gallery_prefs()->AddGalleryChangeObserver(&observer);
1150
1151   path = MakeMediaGalleriesTestingPath("updated_path");
1152   std::string updated_device_id =
1153       StorageInfo::MakeDeviceId(StorageInfo::ITUNES, path.AsUTF8Unsafe());
1154   EXPECT_TRUE(UpdateDeviceIDForSingletonType(updated_device_id));
1155   AddGalleryExpectation(id, gallery_name, updated_device_id, base::FilePath(),
1156                         MediaGalleryPrefInfo::kAutoDetected);
1157   expected_device_map[device_id].erase(id);
1158   expected_device_map[updated_device_id].insert(id);
1159   Verify();
1160   EXPECT_EQ(1, observer.notifications());
1161
1162   // No gallery for type.
1163   std::string new_device_id =
1164       StorageInfo::MakeDeviceId(StorageInfo::PICASA, path.AsUTF8Unsafe());
1165   EXPECT_FALSE(UpdateDeviceIDForSingletonType(new_device_id));
1166 }
1167
1168 TEST_F(MediaGalleriesPreferencesTest, LookupImportedGalleryByPath) {
1169   MediaGalleryPrefId id;
1170   base::FilePath path;
1171   Verify();
1172
1173   // iTunes device path points to an XML file in the library directory.
1174   path = MakeMediaGalleriesTestingPath("new_auto").AppendASCII("library.xml");
1175   base::string16 gallery_name = base::ASCIIToUTF16("NewAutoGallery");
1176   std::string device_id = StorageInfo::MakeDeviceId(StorageInfo::ITUNES,
1177                                                     path.AsUTF8Unsafe());
1178   id = AddGalleryWithNameV2(device_id, gallery_name, base::FilePath(),
1179                             MediaGalleryPrefInfo::kAutoDetected);
1180   EXPECT_EQ(default_galleries_count() + 1UL, id);
1181   AddGalleryExpectation(id, gallery_name, device_id, base::FilePath(),
1182                         MediaGalleryPrefInfo::kAutoDetected);
1183   Verify();
1184
1185   // Verify we can look up the imported gallery by its path.
1186   MediaGalleryPrefInfo gallery_info;
1187   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(path.DirName(),
1188                                                    &gallery_info));
1189   EXPECT_EQ(id, gallery_info.pref_id);
1190 }
1191
1192 TEST_F(MediaGalleriesPreferencesTest, ScanResults) {
1193   MediaGalleryPrefId id;
1194   base::FilePath path;
1195   StorageInfo info;
1196   base::FilePath relative_path;
1197   base::Time now = base::Time::Now();
1198   Verify();
1199
1200   // Add a new scan result gallery to test with.
1201   path = MakeMediaGalleriesTestingPath("new_scan");
1202   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
1203   id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
1204                                    MediaGalleryPrefInfo::kScanResult,
1205                                    ASCIIToUTF16("volume label"),
1206                                    ASCIIToUTF16("vendor name"),
1207                                    ASCIIToUTF16("model name"),
1208                                    1000000ULL, now, 1, 2, 3);
1209   EXPECT_EQ(default_galleries_count() + 1UL, id);
1210   AddScanResultExpectation(id, base::string16(), info.device_id(),
1211                            relative_path, 1, 2, 3);
1212   Verify();
1213
1214   // Update the found media count.
1215   id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
1216                                    MediaGalleryPrefInfo::kScanResult,
1217                                    ASCIIToUTF16("volume label"),
1218                                    ASCIIToUTF16("vendor name"),
1219                                    ASCIIToUTF16("model name"),
1220                                    1000000ULL, now, 4, 5, 6);
1221   EXPECT_EQ(default_galleries_count() + 1UL, id);
1222   AddScanResultExpectation(id, base::string16(), info.device_id(),
1223                            relative_path, 4, 5, 6);
1224   Verify();
1225
1226   // Remove a scan result (i.e. make it blacklisted).
1227   gallery_prefs()->ForgetGalleryById(id);
1228   expected_galleries_[id].type = MediaGalleryPrefInfo::kRemovedScan;
1229   expected_galleries_[id].audio_count = 0;
1230   expected_galleries_[id].image_count = 0;
1231   expected_galleries_[id].video_count = 0;
1232   Verify();
1233
1234   // Try adding the gallery again as a scan result it should be a no-op.
1235   id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
1236                                    MediaGalleryPrefInfo::kScanResult,
1237                                    ASCIIToUTF16("volume label"),
1238                                    ASCIIToUTF16("vendor name"),
1239                                    ASCIIToUTF16("model name"),
1240                                    1000000ULL, now, 7, 8, 9);
1241   EXPECT_EQ(default_galleries_count() + 1UL, id);
1242   Verify();
1243
1244   // Add the gallery again as a user action.
1245   id = gallery_prefs()->AddGalleryByPath(path,
1246                                          MediaGalleryPrefInfo::kUserAdded);
1247   EXPECT_EQ(default_galleries_count() + 1UL, id);
1248   AddGalleryExpectation(id, base::string16(), info.device_id(), relative_path,
1249                         MediaGalleryPrefInfo::kUserAdded);
1250   Verify();
1251 }
1252
1253 TEST(MediaGalleriesPrefInfoTest, NameGeneration) {
1254   ASSERT_TRUE(TestStorageMonitor::CreateAndInstall());
1255
1256   MediaGalleryPrefInfo info;
1257   info.pref_id = 1;
1258   info.display_name = ASCIIToUTF16("override");
1259   info.device_id = StorageInfo::MakeDeviceId(
1260       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, "unique");
1261
1262   EXPECT_EQ(ASCIIToUTF16("override"), info.GetGalleryDisplayName());
1263
1264   info.display_name = ASCIIToUTF16("o2");
1265   EXPECT_EQ(ASCIIToUTF16("o2"), info.GetGalleryDisplayName());
1266
1267   EXPECT_EQ(l10n_util::GetStringUTF16(
1268                 IDS_MEDIA_GALLERIES_DIALOG_DEVICE_NOT_ATTACHED),
1269             info.GetGalleryAdditionalDetails());
1270
1271   info.last_attach_time = base::Time::Now();
1272   EXPECT_NE(l10n_util::GetStringUTF16(
1273                 IDS_MEDIA_GALLERIES_DIALOG_DEVICE_NOT_ATTACHED),
1274             info.GetGalleryAdditionalDetails());
1275   EXPECT_NE(l10n_util::GetStringUTF16(
1276                 IDS_MEDIA_GALLERIES_DIALOG_DEVICE_ATTACHED),
1277             info.GetGalleryAdditionalDetails());
1278
1279   info.volume_label = ASCIIToUTF16("vol");
1280   info.vendor_name = ASCIIToUTF16("vendor");
1281   info.model_name = ASCIIToUTF16("model");
1282   EXPECT_EQ(ASCIIToUTF16("o2"), info.GetGalleryDisplayName());
1283
1284   info.display_name = base::string16();
1285   EXPECT_EQ(ASCIIToUTF16("vol"), info.GetGalleryDisplayName());
1286   info.volume_label = base::string16();
1287   EXPECT_EQ(ASCIIToUTF16("vendor, model"), info.GetGalleryDisplayName());
1288
1289   info.device_id = StorageInfo::MakeDeviceId(
1290       StorageInfo::FIXED_MASS_STORAGE, "unique");
1291   EXPECT_EQ(base::FilePath(FILE_PATH_LITERAL("unique")).AsUTF8Unsafe(),
1292             base::UTF16ToUTF8(info.GetGalleryTooltip()));
1293
1294   TestStorageMonitor::Destroy();
1295 }
1296
1297 TEST_F(MediaGalleriesPreferencesTest, SetsDefaultGalleryTypeField) {
1298   // Tests that default galleries (Music, Pictures, Video) have the correct
1299   // default_gallery field set.
1300
1301   // No default galleries exist on CrOS so this test isn't relevant there.
1302 #if defined(OS_CHROMEOS)
1303   return;
1304 #endif
1305
1306   base::FilePath music_path;
1307   base::FilePath pictures_path;
1308   base::FilePath videos_path;
1309   bool got_music_path = PathService::Get(chrome::DIR_USER_MUSIC, &music_path);
1310   bool got_pictures_path =
1311       PathService::Get(chrome::DIR_USER_PICTURES, &pictures_path);
1312   bool got_videos_path =
1313       PathService::Get(chrome::DIR_USER_VIDEOS, &videos_path);
1314
1315   int num_default_galleries = 0;
1316
1317   const MediaGalleriesPrefInfoMap& known_galleries =
1318       gallery_prefs()->known_galleries();
1319   for (MediaGalleriesPrefInfoMap::const_iterator it =
1320            known_galleries.begin();
1321        it != known_galleries.end();
1322        ++it) {
1323     if (it->second.type != MediaGalleryPrefInfo::kAutoDetected)
1324       continue;
1325
1326     std::string unique_id;
1327     if (!StorageInfo::CrackDeviceId(it->second.device_id, NULL, &unique_id))
1328       continue;
1329
1330     if (got_music_path && unique_id == music_path.AsUTF8Unsafe()) {
1331       EXPECT_EQ(MediaGalleryPrefInfo::DefaultGalleryType::kMusicDefault,
1332                 it->second.default_gallery_type);
1333       num_default_galleries++;
1334     } else if (got_pictures_path && unique_id == pictures_path.AsUTF8Unsafe()) {
1335       EXPECT_EQ(MediaGalleryPrefInfo::DefaultGalleryType::kPicturesDefault,
1336                 it->second.default_gallery_type);
1337       num_default_galleries++;
1338     } else if (got_videos_path && unique_id == videos_path.AsUTF8Unsafe()) {
1339       EXPECT_EQ(MediaGalleryPrefInfo::DefaultGalleryType::kVideosDefault,
1340                 it->second.default_gallery_type);
1341       num_default_galleries++;
1342     } else {
1343       EXPECT_EQ(MediaGalleryPrefInfo::DefaultGalleryType::kNotDefault,
1344                 it->second.default_gallery_type);
1345     }
1346   }
1347
1348   EXPECT_EQ(3, num_default_galleries);
1349 }
1350
1351 TEST_F(MediaGalleriesPreferencesTest, UpdatesDefaultGalleryType) {
1352   // Tests that if the path of a default gallery changed since last init,
1353   // then when the MediaGalleriesPreferences is initialized, it will
1354   // rewrite the device ID in prefs to include the new path.
1355
1356   // No default galleries exist on CrOS so this test isn't relevant there.
1357 #if defined(OS_CHROMEOS)
1358   return;
1359 #endif
1360
1361   base::FilePath old_music_path;
1362   base::FilePath old_pictures_path;
1363   base::FilePath old_videos_path;
1364   bool got_old_music_path =
1365       PathService::Get(chrome::DIR_USER_MUSIC, &old_music_path);
1366   bool got_old_pictures_path =
1367       PathService::Get(chrome::DIR_USER_PICTURES, &old_pictures_path);
1368   bool got_old_videos_path =
1369       PathService::Get(chrome::DIR_USER_VIDEOS, &old_videos_path);
1370
1371   bool found_music = false;
1372   bool found_pictures = false;
1373   bool found_videos = false;
1374
1375   const MediaGalleriesPrefInfoMap& old_known_galleries =
1376       gallery_prefs()->known_galleries();
1377   for (MediaGalleriesPrefInfoMap::const_iterator it =
1378            old_known_galleries.begin();
1379        it != old_known_galleries.end();
1380        ++it) {
1381     if (it->second.type == MediaGalleryPrefInfo::kAutoDetected) {
1382       std::string unique_id;
1383       if (!StorageInfo::CrackDeviceId(it->second.device_id, NULL, &unique_id))
1384         continue;
1385
1386       if (got_old_music_path &&
1387           it->second.default_gallery_type ==
1388           MediaGalleryPrefInfo::DefaultGalleryType::kMusicDefault) {
1389         EXPECT_EQ(old_music_path.AsUTF8Unsafe(), unique_id);
1390         found_music = true;
1391       } else if (got_old_pictures_path &&
1392                  it->second.default_gallery_type ==
1393                  MediaGalleryPrefInfo::DefaultGalleryType::kPicturesDefault) {
1394         EXPECT_EQ(old_pictures_path.AsUTF8Unsafe(), unique_id);
1395         found_pictures = true;
1396       } else if (got_old_videos_path &&
1397                  it->second.default_gallery_type ==
1398                  MediaGalleryPrefInfo::DefaultGalleryType::kVideosDefault) {
1399         EXPECT_EQ(old_videos_path.AsUTF8Unsafe(), unique_id);
1400         found_videos = true;
1401       }
1402     }
1403   }
1404
1405   EXPECT_TRUE(found_music);
1406   EXPECT_TRUE(found_pictures);
1407   EXPECT_TRUE(found_videos);
1408
1409   ChangeMediaPathOverrides();
1410   ReinitPrefsAndExpectations();
1411
1412   base::FilePath new_music_path;
1413   base::FilePath new_pictures_path;
1414   base::FilePath new_videos_path;
1415   bool got_new_music_path =
1416       PathService::Get(chrome::DIR_USER_MUSIC, &new_music_path);
1417   bool got_new_pictures_path =
1418       PathService::Get(chrome::DIR_USER_PICTURES, &new_pictures_path);
1419   bool got_new_videos_path =
1420       PathService::Get(chrome::DIR_USER_VIDEOS, &new_videos_path);
1421
1422   EXPECT_NE(new_music_path, old_music_path);
1423   EXPECT_NE(new_pictures_path, old_pictures_path);
1424   EXPECT_NE(new_videos_path, old_videos_path);
1425
1426   found_music = false;
1427   found_pictures = false;
1428   found_videos = false;
1429
1430   const MediaGalleriesPrefInfoMap& known_galleries =
1431       gallery_prefs()->known_galleries();
1432   for (MediaGalleriesPrefInfoMap::const_iterator it = known_galleries.begin();
1433        it != known_galleries.end();
1434        ++it) {
1435     if (it->second.type == MediaGalleryPrefInfo::kAutoDetected) {
1436       std::string unique_id;
1437       if (!StorageInfo::CrackDeviceId(it->second.device_id, NULL, &unique_id))
1438         continue;
1439
1440       if (got_new_music_path &&
1441           it->second.default_gallery_type ==
1442           MediaGalleryPrefInfo::DefaultGalleryType::kMusicDefault) {
1443         EXPECT_EQ(new_music_path.AsUTF8Unsafe(), unique_id);
1444         found_music = true;
1445       } else if (got_new_pictures_path &&
1446                  it->second.default_gallery_type ==
1447                  MediaGalleryPrefInfo::DefaultGalleryType::kPicturesDefault) {
1448         EXPECT_EQ(new_pictures_path.AsUTF8Unsafe(), unique_id);
1449         found_pictures = true;
1450       } else if (got_new_videos_path &&
1451                  it->second.default_gallery_type ==
1452                  MediaGalleryPrefInfo::DefaultGalleryType::kVideosDefault) {
1453         EXPECT_EQ(new_videos_path.AsUTF8Unsafe(), unique_id);
1454         found_videos = true;
1455       }
1456     }
1457   }
1458
1459   EXPECT_TRUE(found_music);
1460   EXPECT_TRUE(found_pictures);
1461   EXPECT_TRUE(found_videos);
1462 }
1463
1464 TEST_F(MediaGalleriesPreferencesTest, UpdateAddsDefaultGalleryTypeIfMissing) {
1465   // Tests that if no default_gallery_type was specified for an existing prefs
1466   // info object corresponding to a particular gallery, then when the
1467   // MediaGalleriesPreferences is initialized, it assigns the proper one.
1468
1469   // No default galleries exist on CrOS so this test isn't relevant there.
1470 #if defined(OS_CHROMEOS)
1471   return;
1472 #endif
1473
1474   // Add a new user added gallery.
1475   AddFixedGalleryWithExepectation("user_added", "UserAdded",
1476                                   MediaGalleryPrefInfo::kUserAdded);
1477
1478   // Remove the "default_gallery_type" field completely from the persisted data
1479   // for the prefs info object. This simulates the case where a user updated
1480   // Chrome from a version without that field to one with it.
1481   RemovePersistedDefaultGalleryValues();
1482
1483   // Reinitializing the MediaGalleriesPreferences should populate the
1484   // default_gallery_type field with the correct value for each gallery.
1485   ReinitPrefsAndExpectations();
1486
1487   base::FilePath music_path;
1488   base::FilePath pictures_path;
1489   base::FilePath videos_path;
1490   bool got_music_path = PathService::Get(chrome::DIR_USER_MUSIC, &music_path);
1491   bool got_pictures_path =
1492       PathService::Get(chrome::DIR_USER_PICTURES, &pictures_path);
1493   bool got_videos_path =
1494       PathService::Get(chrome::DIR_USER_VIDEOS, &videos_path);
1495
1496   bool found_music = false;
1497   bool found_pictures = false;
1498   bool found_videos = false;
1499   bool found_user_added = false;
1500
1501   const MediaGalleriesPrefInfoMap& known_galleries =
1502       gallery_prefs()->known_galleries();
1503   for (MediaGalleriesPrefInfoMap::const_iterator it = known_galleries.begin();
1504        it != known_galleries.end();
1505        ++it) {
1506     std::string unique_id;
1507     if (!StorageInfo::CrackDeviceId(it->second.device_id, NULL, &unique_id))
1508       continue;
1509
1510     if (got_music_path &&
1511         it->second.default_gallery_type ==
1512         MediaGalleryPrefInfo::DefaultGalleryType::kMusicDefault) {
1513       EXPECT_EQ(music_path.AsUTF8Unsafe(), unique_id);
1514       found_music = true;
1515     } else if (got_pictures_path &&
1516                it->second.default_gallery_type ==
1517                MediaGalleryPrefInfo::DefaultGalleryType::kPicturesDefault) {
1518       EXPECT_EQ(pictures_path.AsUTF8Unsafe(), unique_id);
1519       found_pictures = true;
1520     } else if (got_videos_path &&
1521                it->second.default_gallery_type ==
1522                MediaGalleryPrefInfo::DefaultGalleryType::kVideosDefault) {
1523       EXPECT_EQ(videos_path.AsUTF8Unsafe(), unique_id);
1524       found_videos = true;
1525     } else if (it->second.default_gallery_type ==
1526                MediaGalleryPrefInfo::DefaultGalleryType::kNotDefault) {
1527       found_user_added = true;
1528     }
1529   }
1530
1531   EXPECT_TRUE(found_music);
1532   EXPECT_TRUE(found_pictures);
1533   EXPECT_TRUE(found_videos);
1534   EXPECT_TRUE(found_user_added);
1535 }