PreferencesManager

services/preferences/public/cpp/tests/pref_observer_store_unittest.cc

 // Copyright 2016 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.
 
 #include "services/preferences/public/cpp/pref_observer_store.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 15 matching lines @@
         binding_(this, std::move(request)) {}
   ~TestPreferenceManager() override {}
 
   bool add_observer_called() { return add_observer_called_; }
   const std::set<std::string>& last_preference_set() {
     return last_preference_set_;
   }
   bool set_preferences_called() { return set_preferences_called_; }
 
   // prefs::mojom::TestPreferenceManager:
-  void AddObserver(const std::vector<std::string>& preferences,
-                   prefs::mojom::PreferencesObserverPtr client) override;
+  void AddObserver(prefs::mojom::PreferencesObserverPtr client) override;
   void SetPreferences(
       std::unique_ptr<base::DictionaryValue> preferences) override;
+  void Subscribe(const std::vector<std::string>& preferences) override;
 
  private:
   bool add_observer_called_;
   std::set<std::string> last_preference_set_;
   bool set_preferences_called_;
   mojo::Binding<PreferencesManager> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPreferenceManager);
 };
 
 void TestPreferenceManager::AddObserver(
-    const std::vector<std::string>& preferences,
     prefs::mojom::PreferencesObserverPtr client) {
   add_observer_called_ = true;
-  last_preference_set_.clear();
-  last_preference_set_.insert(preferences.begin(), preferences.end());
 }
 
 void TestPreferenceManager::SetPreferences(
     std::unique_ptr<base::DictionaryValue> preferences) {
   set_preferences_called_ = true;
 }
 
+void TestPreferenceManager::Subscribe(
+    const std::vector<std::string>& preferences) {
+  last_preference_set_.clear();
+  last_preference_set_.insert(preferences.begin(), preferences.end());
+}
+
 }  // namespace
 
+namespace preferences {
+
 class PrefObserverStoreTest : public testing::Test {
  public:
   PrefObserverStoreTest() {}
   ~PrefObserverStoreTest() override {}
 
   TestPreferenceManager* manager() { return manager_.get(); }
   PrefStoreObserverMock* observer() { return &observer_; }
   PrefObserverStore* store() { return store_.get(); }
 
   bool Initialized() { return store_->initialized_; }
@@ skipping 25 matching lines @@
 void PrefObserverStoreTest::TearDown() {
   store_->RemoveObserver(&observer_);
 }
 
 // Tests that observers are notified upon the completion of initialization, and
 // that values become available.
 TEST_F(PrefObserverStoreTest, Initialization) {
   std::set<std::string> keys;
   const std::string key("hey");
   keys.insert(key);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   EXPECT_FALSE(Initialized());
   EXPECT_FALSE(observer()->initialized);
 
   const int kValue = 42;
   base::FundamentalValue pref(kValue);
   base::DictionaryValue prefs;
   prefs.Set(key, pref.CreateDeepCopy());
 
   // PreferenceManager notifies of PreferencesChanged, completing
@@ skipping 12 matching lines @@
   EXPECT_EQ(kValue, actual_value);
   EXPECT_FALSE(manager()->set_preferences_called());
 }
 
 // Tests that values set silently are also set on the preference manager, but
 // that no observers are notified.
 TEST_F(PrefObserverStoreTest, SetValueSilently) {
   std::set<std::string> keys;
   const std::string key("hey");
   keys.insert(key);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   const int kValue = 42;
   base::FundamentalValue pref(kValue);
   store()->SetValueSilently(key, pref.CreateDeepCopy(), 0);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(manager()->set_preferences_called());
   EXPECT_TRUE(observer()->changed_keys.empty());
 }
 
 // Test that reporting values changed notifies observers, and the preference
 // manager.
 TEST_F(PrefObserverStoreTest, ReportValueChanged) {
   std::set<std::string> keys;
   const std::string key("hey");
   keys.insert(key);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   const int kValue = 42;
   base::FundamentalValue pref(kValue);
   base::DictionaryValue prefs;
   prefs.Set(key, pref.CreateDeepCopy());
   OnPreferencesChanged(prefs);
   observer()->changed_keys.clear();
 
   store()->ReportValueChanged(key, 0);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(manager()->set_preferences_called());
   observer()->VerifyAndResetChangedKey(key);
 }
 
 // Test that when initialized with multiple keys, that observers receive a
 // notification for each key.
 TEST_F(PrefObserverStoreTest, MultipleKeyInitialization) {
   std::set<std::string> keys;
   const std::string key1("hey");
   const std::string key2("listen");
   keys.insert(key1);
   keys.insert(key2);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   EXPECT_FALSE(Initialized());
   EXPECT_FALSE(observer()->initialized);
 
   const int kValue = 42;
   base::FundamentalValue pref1(kValue);
   const std::string kStringValue("look");
   base::StringValue pref2(kStringValue);
 
   base::DictionaryValue prefs;
@@ skipping 12 matching lines @@
             std::find(observer()->changed_keys.begin(),
                       observer()->changed_keys.end(), key2));
 }
 
 // Tests that if OnPreferencesChanged is received with invalid keys, that they
 // are ignored.
 TEST_F(PrefObserverStoreTest, InvalidInitialization) {
   std::set<std::string> keys;
   const std::string key("hey");
   keys.insert(key);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   const std::string kInvalidKey("look");
   const int kValue = 42;
   base::FundamentalValue pref(kValue);
   base::DictionaryValue prefs;
   prefs.Set(kInvalidKey, pref.CreateDeepCopy());
 
   OnPreferencesChanged(prefs);
   EXPECT_TRUE(observer()->changed_keys.empty());
 }
 
 // Tests that when tracking preferences which nest other DictionaryValues, that
 // modifications to the nested values properly notify the observer.
 TEST_F(PrefObserverStoreTest, WriteToNestedPrefs) {
   std::set<std::string> keys;
   const std::string key1("hey");
   const std::string key2("listen");
   keys.insert(key1);
   keys.insert(key2);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   EXPECT_FALSE(Initialized());
   EXPECT_FALSE(observer()->initialized);
 
   const std::string sub_key1("look");
   const int kValue1 = 42;
   base::FundamentalValue pref1(kValue1);
   base::DictionaryValue sub_dictionary1;
   sub_dictionary1.Set(sub_key1, pref1.CreateDeepCopy());
 
@@ skipping 40 matching lines @@
 }
 
 // Tests that when tracking preferences that nest other DictionaryValues, that
 // changes to the tracked keys properly notify the manager and observer.
 TEST_F(PrefObserverStoreTest, UpdateOuterNestedPrefs) {
   std::set<std::string> keys;
   const std::string key1("hey");
   const std::string key2("listen");
   keys.insert(key1);
   keys.insert(key2);
-  store()->Init(keys);
+  store()->Subscribe(keys);
 
   EXPECT_FALSE(Initialized());
   EXPECT_FALSE(observer()->initialized);
 
   const std::string sub_key1("look");
   const int kValue1 = 42;
   base::FundamentalValue pref1(kValue1);
   base::DictionaryValue sub_dictionary1;
   sub_dictionary1.Set(sub_key1, pref1.CreateDeepCopy());
 
@@ skipping 20 matching lines @@
                       observer()->changed_keys.end(), key2));
 
   observer()->changed_keys.clear();
   const int kValue3 = 9001;
   base::FundamentalValue pref3(kValue3);
   store()->SetValue(key1, pref3.CreateDeepCopy(), 0);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, observer()->changed_keys.size());
   EXPECT_TRUE(manager()->set_preferences_called());
 }
+
+// Tests that a PrefObserverStore can subscribe multiple times to different
+// keys.
+TEST_F(PrefObserverStoreTest, MultipleSubscriptions) {
+  std::set<std::string> keys1;
+  const std::string key1("hey");
+  keys1.insert(key1);
+  store()->Subscribe(keys1);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_NE(manager()->last_preference_set().end(),
+            manager()->last_preference_set().find(key1));
+
+  std::set<std::string> keys2;
+  const std::string key2("listen");
+  keys2.insert(key2);
+  store()->Subscribe(keys2);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_NE(manager()->last_preference_set().end(),
+            manager()->last_preference_set().find(key2));
+}
+
+// Tests that multiple PrefStore::Observers can be added to a PrefObserverStore
+// and that they are each notified of changes.
+TEST_F(PrefObserverStoreTest, MultipleObservers) {
+  PrefStoreObserverMock observer2;
+  store()->AddObserver(&observer2);
+
+  std::set<std::string> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Subscribe(keys);
+
+  const int kValue = 42;
+  base::FundamentalValue pref(kValue);
+  base::DictionaryValue prefs;
+  prefs.Set(key, pref.CreateDeepCopy());
+
+  // PreferenceManager notifies of PreferencesChanged, completing
+  // initialization.
+  OnPreferencesChanged(prefs);
+  EXPECT_TRUE(observer()->initialized);
+  EXPECT_TRUE(observer2.initialized);
+  EXPECT_TRUE(observer()->initialization_success);
+  EXPECT_TRUE(observer2.initialization_success);
+  observer()->VerifyAndResetChangedKey(key);
+  observer2.VerifyAndResetChangedKey(key);
+
+  store()->RemoveObserver(&observer2);
+}
+
+}  // namespace preferences