Media Galleries: Add MediaGalleriesPreferences::GalleryChangeObserver class.

chrome/browser/media_gallery/media_galleries_preferences_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // MediaGalleriesPreferences unit tests.
 
 #include "chrome/browser/media_gallery/media_galleries_preferences.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 31 matching lines @@
     if (device_id)
       *device_id = MakeDeviceId(FIXED_MASS_STORAGE, path.AsUTF8Unsafe());
     if (device_name)
       *device_name = path.BaseName().LossyDisplayName();
     if (relative_path)
       *relative_path = FilePath();
     return true;
   }
 };
 
+class MockGalleryChangeObserver
+    : public MediaGalleriesPreferences::GalleryChangeObserver {
+ public:
+  explicit MockGalleryChangeObserver(MediaGalleriesPreferences* pref)
+      : pref_(pref),
+        notifications_(0) {}
+  virtual ~MockGalleryChangeObserver() {}
+
+  int notifications() const { return notifications_;}
+
+ private:
+  // MediaGalleriesPreferences::GalleryChangeObserver implementation.
+  virtual void OnGalleryChanged(MediaGalleriesPreferences* pref) OVERRIDE {
+    EXPECT_EQ(pref_, pref);
+    ++notifications_;
+  }
+
+  MediaGalleriesPreferences* pref_;
+  int notifications_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockGalleryChangeObserver);
+};
+
 class MediaGalleriesPreferencesTest : public testing::Test {
  public:
   typedef std::map<std::string /*device id*/, MediaGalleryPrefIdSet>
       DeviceIdPrefIdsMap;
 
   MediaGalleriesPreferencesTest()
       : ui_thread_(content::BrowserThread::UI, &loop_),
         file_thread_(content::BrowserThread::FILE, &loop_),
         profile_(new TestingProfile()),
         default_galleries_count_(0) {
@@ skipping 48 matching lines @@
     Verify();
   }
 
   void Verify() {
     const MediaGalleriesPrefInfoMap& known_galleries =
         gallery_prefs_->known_galleries();
     EXPECT_EQ(expected_galleries_.size(), known_galleries.size());
     for (MediaGalleriesPrefInfoMap::const_iterator it = known_galleries.begin();
          it != known_galleries.end();
          ++it) {
-      VerifyGalleryInfo(&it->second, it->first);
+      VerifyGalleryInfo(it->second, it->first);
     }
 
     for (DeviceIdPrefIdsMap::const_iterator it = expected_device_map.begin();
          it != expected_device_map.end();
          ++it) {
       MediaGalleryPrefIdSet actual_id_set =
           gallery_prefs_->LookUpGalleriesByDeviceId(it->first);
       EXPECT_EQ(it->second, actual_id_set);
     }
 
     std::set<MediaGalleryPrefId> galleries_for_all =
         gallery_prefs_->GalleriesForExtension(*all_permission_extension.get());
     EXPECT_EQ(expected_galleries_for_all, galleries_for_all);
 
     std::set<MediaGalleryPrefId> galleries_for_regular =
         gallery_prefs_->GalleriesForExtension(
             *regular_permission_extension.get());
     EXPECT_EQ(expected_galleries_for_regular, galleries_for_regular);
 
     std::set<MediaGalleryPrefId> galleries_for_no =
         gallery_prefs_->GalleriesForExtension(*no_permissions_extension.get());
     EXPECT_EQ(0U, galleries_for_no.size());
   }
 
-  void VerifyGalleryInfo(const MediaGalleryPrefInfo* actual,
+  void VerifyGalleryInfo(const MediaGalleryPrefInfo& actual,
                          MediaGalleryPrefId expected_id) const {
     MediaGalleriesPrefInfoMap::const_iterator in_expectation =
       expected_galleries_.find(expected_id);
-    EXPECT_FALSE(in_expectation == expected_galleries_.end());
-    EXPECT_EQ(in_expectation->second.pref_id, actual->pref_id);
-    EXPECT_EQ(in_expectation->second.display_name, actual->display_name);
-    EXPECT_EQ(in_expectation->second.device_id, actual->device_id);
-    EXPECT_EQ(in_expectation->second.path.value(), actual->path.value());
-    EXPECT_EQ(in_expectation->second.type, actual->type);
+    ASSERT_FALSE(in_expectation == expected_galleries_.end())  << expected_id;
+    EXPECT_EQ(in_expectation->second.pref_id, actual.pref_id);
+    EXPECT_EQ(in_expectation->second.display_name, actual.display_name);
+    EXPECT_EQ(in_expectation->second.device_id, actual.device_id);
+    EXPECT_EQ(in_expectation->second.path.value(), actual.path.value());
+    EXPECT_EQ(in_expectation->second.type, actual.type);
   }
 
   MediaGalleriesPreferences* gallery_prefs() {
     return gallery_prefs_.get();
   }
 
   uint64 default_galleries_count() {
     return default_galleries_count_;
   }
 
@@ skipping 89 matching lines @@
 
   // Lookup some galleries.
   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(MakePath("new_auto"), NULL));
   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(MakePath("new_user"), NULL));
   EXPECT_FALSE(gallery_prefs()->LookUpGalleryByPath(MakePath("other"), NULL));
 
   // Check that we always get the gallery info.
   MediaGalleryPrefInfo gallery_info;
   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(MakePath("new_auto"),
                                                    &gallery_info));
-  VerifyGalleryInfo(&gallery_info, auto_id);
+  VerifyGalleryInfo(gallery_info, auto_id);
   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(MakePath("new_user"),
                                                    &gallery_info));
-  VerifyGalleryInfo(&gallery_info, user_added_id);
+  VerifyGalleryInfo(gallery_info, user_added_id);
 
   path = MakePath("other");
   EXPECT_FALSE(gallery_prefs()->LookUpGalleryByPath(path, &gallery_info));
   EXPECT_EQ(kInvalidMediaGalleryPrefId, gallery_info.pref_id);
   EXPECT_EQ(path.BaseName().LossyDisplayName(), gallery_info.display_name);
   std::string other_device_id;
   MediaStorageUtil::GetDeviceInfoFromPath(path, &other_device_id, NULL,
                                           &relative_path);
   EXPECT_EQ(other_device_id, gallery_info.device_id);
   EXPECT_EQ(relative_path.value(), gallery_info.path.value());
@@ skipping 274 matching lines @@
                         MediaGalleryPrefInfo::kUserAdded);
   Verify();
 
   // Check that adding one of them again works as expected.
   MediaGalleryPrefId id = gallery_prefs()->AddGallery(
       device_id, device_name, relative_path, true /*user*/);
   EXPECT_EQ(dev2_path2_id, id);
   Verify();
 }
 
+TEST_F(MediaGalleriesPreferencesTest, GalleryChangeObserver) {
+  // Start with one observer.
+  MockGalleryChangeObserver observer1(gallery_prefs());
+  gallery_prefs()->AddGalleryChangeObserver(&observer1);
+
+  // Add a new auto detected gallery.
+  string16 device_name = ASCIIToUTF16("NewAutoGallery");
+  FilePath path = MakePath("new_auto");
+  std::string device_id;
+  FilePath relative_path;
+  MediaStorageUtil::GetDeviceInfoFromPath(path, &device_id, NULL,
+                                          &relative_path);
+  MediaGalleryPrefId auto_id =
+      gallery_prefs()->AddGallery(device_id, device_name, relative_path,
+                                  false /*auto*/);
+  EXPECT_EQ(default_galleries_count() + 1UL, auto_id);
+  AddGalleryExpectation(auto_id, device_name, device_id, relative_path,
+                        MediaGalleryPrefInfo::kAutoDetected);
+  EXPECT_EQ(1, observer1.notifications());
+
+  // Add a second observer.
+  MockGalleryChangeObserver observer2(gallery_prefs());
+  gallery_prefs()->AddGalleryChangeObserver(&observer2);
+
+  // Add a new user added gallery.
+  path = MakePath("new_user");
+  MediaStorageUtil::GetDeviceInfoFromPath(path, &device_id, NULL,
+                                          &relative_path);
+  device_name = ASCIIToUTF16("NewUserGallery");
+  MediaGalleryPrefId user_added_id =
+      gallery_prefs()->AddGallery(device_id, device_name, relative_path,
+                                  true /*user*/);
+  AddGalleryExpectation(user_added_id, device_name, device_id, relative_path,
+                        MediaGalleryPrefInfo::kUserAdded);
+  EXPECT_EQ(default_galleries_count() + 2UL, user_added_id);
+  EXPECT_EQ(2, observer1.notifications());
+  EXPECT_EQ(1, observer2.notifications());
+
+  // Remove the first observer.
+  gallery_prefs()->RemoveGalleryChangeObserver(&observer1);
+
+  // Remove an auto added gallery (i.e. make it blacklisted).
+  gallery_prefs()->ForgetGalleryById(auto_id);
+  expected_galleries_[auto_id].type = MediaGalleryPrefInfo::kBlackListed;
+  expected_galleries_for_all.erase(auto_id);
+
+  EXPECT_EQ(2, observer1.notifications());
+  EXPECT_EQ(2, observer2.notifications());
+
+  // Remove a user added gallery and it should go away.
+  gallery_prefs()->ForgetGalleryById(user_added_id);
+  expected_galleries_.erase(user_added_id);
+  expected_device_map[device_id].erase(user_added_id);
+
+  EXPECT_EQ(2, observer1.notifications());
+  EXPECT_EQ(3, observer2.notifications());
+}
+
 }  // namespace
 
 }  // namespace chrome