Create a DefaultPrefStore to hold registered application-default preference v...

chrome/browser/prefs/pref_notifier_unittest.cc

 // Copyright (c) 2010 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 "chrome/browser/prefs/default_pref_store.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/notification_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 
@@ skipping 33 matching lines @@
     size_t count = 0;
     while ((existing_obs = it.GetNext()) != NULL) {
       if (existing_obs == obs)
         count++;
     }
 
     return count;
   }
 };
 
-// Mock PrefValueStore that has no PrefStores and injects a simpler
+// Mock PrefValueStore that has no unnecessary PrefStores and injects a simpler
 // PrefHasChanged().
 class MockPrefValueStore : public PrefValueStore {
  public:
-  MockPrefValueStore() : PrefValueStore(NULL, NULL, NULL, NULL, NULL) {}
+  MockPrefValueStore()
+      : PrefValueStore(NULL, NULL, NULL, NULL, NULL, new DefaultPrefStore()) {}
 
   virtual ~MockPrefValueStore() {}
 
   // This mock version returns true if the pref path starts with "changed".
   virtual bool PrefHasChanged(const char* path,
-                              PrefNotifier::PrefStoreType new_store,
-                              const Value* old_value) {
+                              PrefNotifier::PrefStoreType new_store) {
     std::string path_str(path);
     if (path_str.compare(0, 7, "changed") == 0)
       return true;
     return false;
   }
 };
 
 // Mock PrefService that allows the PrefNotifier to be injected.
 class MockPrefService : public PrefService {
  public:
@@ skipping 16 matching lines @@
 };
 
 // Test fixture class.
 class PrefNotifierTest : public testing::Test {
  protected:
   virtual void SetUp() {
     value_store_ = new MockPrefValueStore;
     pref_service_.reset(new MockPrefService(value_store_));
     notifier_ = new MockPrefNotifier(pref_service_.get(), value_store_);
     pref_service_->SetPrefNotifier(notifier_);
+
+    pref_service_->RegisterBooleanPref(kChangedPref, true);
+    pref_service_->RegisterBooleanPref(kUnchangedPref, true);
   }
 
   // The PrefService takes ownership of the PrefValueStore and PrefNotifier.
   PrefValueStore* value_store_;
   MockPrefNotifier* notifier_;
   scoped_ptr<MockPrefService> pref_service_;
 
   MockPrefObserver obs1_;
   MockPrefObserver obs2_;
 };
 
-
 TEST_F(PrefNotifierTest, OnPreferenceSet) {
   EXPECT_CALL(*notifier_, FireObservers(kChangedPref))
       .Times(PrefNotifier::PREF_STORE_TYPE_MAX + 1);
   EXPECT_CALL(*notifier_, FireObservers(kUnchangedPref)).Times(0);
 
   for (size_t i = 0; i <= PrefNotifier::PREF_STORE_TYPE_MAX; ++i) {
     notifier_->OnPreferenceSet(kChangedPref,
-        static_cast<PrefNotifier::PrefStoreType>(i), NULL);
+        static_cast<PrefNotifier::PrefStoreType>(i));
     notifier_->OnPreferenceSet(kUnchangedPref,
-        static_cast<PrefNotifier::PrefStoreType>(i), NULL);
+        static_cast<PrefNotifier::PrefStoreType>(i));
   }
 }
 
 TEST_F(PrefNotifierTest, OnUserPreferenceSet) {
   EXPECT_CALL(*notifier_, FireObservers(kChangedPref));
   EXPECT_CALL(*notifier_, FireObservers(kUnchangedPref)).Times(0);
-  notifier_->OnUserPreferenceSet(kChangedPref, NULL);
-  notifier_->OnUserPreferenceSet(kUnchangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kChangedPref);
+  notifier_->OnUserPreferenceSet(kUnchangedPref);
 }
 
 TEST_F(PrefNotifierTest, AddAndRemovePrefObservers) {
   const char pref_name[] = "homepage";
   const char pref_name2[] = "proxy";
 
   notifier_->AddPrefObserver(pref_name, &obs1_);
   ASSERT_EQ(1u, notifier_->CountObserver(pref_name, &obs1_));
   ASSERT_EQ(0u, notifier_->CountObserver(pref_name2, &obs1_));
   ASSERT_EQ(0u, notifier_->CountObserver(pref_name, &obs2_));
@@ skipping 65 matching lines @@
   EXPECT_CALL(*notifier_, FireObservers(kUnchangedPref)).Times(0);
 
   notifier_->AddPrefObserver(kChangedPref, &obs1_);
   notifier_->AddPrefObserver(kUnchangedPref, &obs1_);
 
   EXPECT_CALL(obs1_, Observe(
       Field(&NotificationType::value, NotificationType::PREF_CHANGED),
       Source<PrefService>(pref_service_.get()),
       Truly(DetailsAreChangedPref)));
   EXPECT_CALL(obs2_, Observe(_, _, _)).Times(0);
-  notifier_->OnUserPreferenceSet(kChangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kChangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   EXPECT_CALL(obs1_, Observe(_, _, _)).Times(0);
   EXPECT_CALL(obs2_, Observe(_, _, _)).Times(0);
-  notifier_->OnUserPreferenceSet(kUnchangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kUnchangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   notifier_->AddPrefObserver(kChangedPref, &obs2_);
   notifier_->AddPrefObserver(kUnchangedPref, &obs2_);
 
   EXPECT_CALL(obs1_, Observe(
       Field(&NotificationType::value, NotificationType::PREF_CHANGED),
       Source<PrefService>(pref_service_.get()),
       Truly(DetailsAreChangedPref)));
   EXPECT_CALL(obs2_, Observe(
       Field(&NotificationType::value, NotificationType::PREF_CHANGED),
       Source<PrefService>(pref_service_.get()),
       Truly(DetailsAreChangedPref)));
-  notifier_->OnUserPreferenceSet(kChangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kChangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   EXPECT_CALL(obs1_, Observe(_, _, _)).Times(0);
   EXPECT_CALL(obs2_, Observe(_, _, _)).Times(0);
-  notifier_->OnUserPreferenceSet(kUnchangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kUnchangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   // Make sure removing an observer from one pref doesn't affect anything else.
   notifier_->RemovePrefObserver(kChangedPref, &obs1_);
 
   EXPECT_CALL(obs1_, Observe(_, _, _)).Times(0);
   EXPECT_CALL(obs2_, Observe(
       Field(&NotificationType::value, NotificationType::PREF_CHANGED),
       Source<PrefService>(pref_service_.get()),
       Truly(DetailsAreChangedPref)));
-  notifier_->OnUserPreferenceSet(kChangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kChangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   EXPECT_CALL(obs1_, Observe(_, _, _)).Times(0);
   EXPECT_CALL(obs2_, Observe(_, _, _)).Times(0);
-  notifier_->OnUserPreferenceSet(kUnchangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kUnchangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   // Make sure removing an observer entirely doesn't affect anything else.
   notifier_->RemovePrefObserver(kUnchangedPref, &obs1_);
 
   EXPECT_CALL(obs1_, Observe(_, _, _)).Times(0);
   EXPECT_CALL(obs2_, Observe(
       Field(&NotificationType::value, NotificationType::PREF_CHANGED),
       Source<PrefService>(pref_service_.get()),
       Truly(DetailsAreChangedPref)));
-  notifier_->OnUserPreferenceSet(kChangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kChangedPref);
   Mock::VerifyAndClearExpectations(&obs1_);
   Mock::VerifyAndClearExpectations(&obs2_);
 
   EXPECT_CALL(obs1_, Observe(_, _, _)).Times(0);
   EXPECT_CALL(obs2_, Observe(_, _, _)).Times(0);
-  notifier_->OnUserPreferenceSet(kUnchangedPref, NULL);
+  notifier_->OnUserPreferenceSet(kUnchangedPref);
 
   notifier_->RemovePrefObserver(kChangedPref, &obs2_);
   notifier_->RemovePrefObserver(kUnchangedPref, &obs2_);
 }
 
 }  // namespace