Remove the last usages of PrefObserver outside of Prefs.

chrome/browser/prefs/pref_service_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.
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/public/pref_change_registrar.h"
 #include "base/prefs/testing_pref_store.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
-#include "chrome/browser/prefs/pref_observer_mock.h"
+#include "chrome/browser/prefs/mock_pref_change_callback.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/test/data/resource.h"
 #include "webkit/glue/webpreferences.h"
 
 using content::BrowserThread;
 using content::WebContentsTester;
 using testing::_;
 using testing::Mock;
 
 TEST(PrefServiceTest, NoObserverFire) {
   TestingPrefService prefs;
 
   const char pref_name[] = "homepage";
   prefs.RegisterStringPref(pref_name, std::string());
 
   const char new_pref_value[] = "http://www.google.com/";
-  PrefObserverMock obs;
+  MockPrefChangeCallback obs(&prefs);
   PrefChangeRegistrar registrar;
   registrar.Init(&prefs);
-  registrar.Add(pref_name, &obs);
+  registrar.Add(pref_name, obs.GetCallback());
 
-  // This should fire the checks in PrefObserverMock::Observe.
+  // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged.
   const StringValue expected_value(new_pref_value);
-  obs.Expect(&prefs, pref_name, &expected_value);
+  obs.Expect(pref_name, &expected_value);
   prefs.SetString(pref_name, new_pref_value);
   Mock::VerifyAndClearExpectations(&obs);
 
   // Setting the pref to the same value should not set the pref value a second
   // time.
-  EXPECT_CALL(obs, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
   prefs.SetString(pref_name, new_pref_value);
   Mock::VerifyAndClearExpectations(&obs);
 
   // Clearing the pref should cause the pref to fire.
   const StringValue expected_default_value("");
-  obs.Expect(&prefs, pref_name, &expected_default_value);
+  obs.Expect(pref_name, &expected_default_value);
   prefs.ClearPref(pref_name);
   Mock::VerifyAndClearExpectations(&obs);
 
   // Clearing the pref again should not cause the pref to fire.
-  EXPECT_CALL(obs, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
   prefs.ClearPref(pref_name);
   Mock::VerifyAndClearExpectations(&obs);
 }
 
 TEST(PrefServiceTest, HasPrefPath) {
   TestingPrefService prefs;
 
   const char path[] = "fake.path";
 
   // Shouldn't initially have a path.
@@ skipping 11 matching lines @@
 
 TEST(PrefServiceTest, Observers) {
   const char pref_name[] = "homepage";
 
   TestingPrefService prefs;
   prefs.SetUserPref(pref_name, Value::CreateStringValue("http://www.cnn.com"));
   prefs.RegisterStringPref(pref_name, std::string());
 
   const char new_pref_value[] = "http://www.google.com/";
   const StringValue expected_new_pref_value(new_pref_value);
-  PrefObserverMock obs;
+  MockPrefChangeCallback obs(&prefs);
   PrefChangeRegistrar registrar;
   registrar.Init(&prefs);
-  registrar.Add(pref_name, &obs);
+  registrar.Add(pref_name, obs.GetCallback());
 
   PrefChangeRegistrar registrar_two;
   registrar_two.Init(&prefs);
 
-  // This should fire the checks in PrefObserverMock::Observe.
-  obs.Expect(&prefs, pref_name, &expected_new_pref_value);
+  // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged.
+  obs.Expect(pref_name, &expected_new_pref_value);
   prefs.SetString(pref_name, new_pref_value);
   Mock::VerifyAndClearExpectations(&obs);
 
   // Now try adding a second pref observer.
   const char new_pref_value2[] = "http://www.youtube.com/";
   const StringValue expected_new_pref_value2(new_pref_value2);
-  PrefObserverMock obs2;
-  obs.Expect(&prefs, pref_name, &expected_new_pref_value2);
-  obs2.Expect(&prefs, pref_name, &expected_new_pref_value2);
-  registrar_two.Add(pref_name, &obs2);
+  MockPrefChangeCallback obs2(&prefs);
+  obs.Expect(pref_name, &expected_new_pref_value2);
+  obs2.Expect(pref_name, &expected_new_pref_value2);
+  registrar_two.Add(pref_name, obs2.GetCallback());
   // This should fire the checks in obs and obs2.
   prefs.SetString(pref_name, new_pref_value2);
   Mock::VerifyAndClearExpectations(&obs);
   Mock::VerifyAndClearExpectations(&obs2);
 
   // Set a recommended value.
   const StringValue recommended_pref_value("http://www.gmail.com/");
-  obs.Expect(&prefs, pref_name, &expected_new_pref_value2);
-  obs2.Expect(&prefs, pref_name, &expected_new_pref_value2);
+  obs.Expect(pref_name, &expected_new_pref_value2);
+  obs2.Expect(pref_name, &expected_new_pref_value2);
   // This should fire the checks in obs and obs2 but with an unchanged value
   // as the recommended value is being overridden by the user-set value.
   prefs.SetRecommendedPref(pref_name, recommended_pref_value.DeepCopy());
   Mock::VerifyAndClearExpectations(&obs);
   Mock::VerifyAndClearExpectations(&obs2);
 
   // Make sure obs2 still works after removing obs.
   registrar.Remove(pref_name);
-  EXPECT_CALL(obs, OnPreferenceChanged(_, _)).Times(0);
-  obs2.Expect(&prefs, pref_name, &expected_new_pref_value);
+  EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
+  obs2.Expect(pref_name, &expected_new_pref_value);
   // This should only fire the observer in obs2.
   prefs.SetString(pref_name, new_pref_value);
   Mock::VerifyAndClearExpectations(&obs);
   Mock::VerifyAndClearExpectations(&obs2);
 }
 
 // Make sure that if a preference changes type, so the wrong type is stored in
 // the user pref file, it uses the correct fallback value instead.
 TEST(PrefServiceTest, GetValueChangedType) {
   const int kTestValue = 10;
@@ skipping 199 matching lines @@
       data_dir_.AppendASCII("write.golden.need_empty_value.json");
   ASSERT_TRUE(file_util::PathExists(golden_output_file));
   EXPECT_TRUE(file_util::TextContentsEqual(golden_output_file, pref_file));
 }
 
 class PrefServiceSetValueTest : public testing::Test {
  protected:
   static const char kName[];
   static const char kValue[];
 
+  PrefServiceSetValueTest() : observer_(&prefs_) {}
+
   TestingPrefService prefs_;
-  PrefObserverMock observer_;
+  MockPrefChangeCallback observer_;
 };
 
 const char PrefServiceSetValueTest::kName[] = "name";
 const char PrefServiceSetValueTest::kValue[] = "value";
 
 TEST_F(PrefServiceSetValueTest, SetStringValue) {
   const char default_string[] = "default";
   const StringValue default_value(default_string);
   prefs_.RegisterStringPref(kName, default_string);
 
   PrefChangeRegistrar registrar;
   registrar.Init(&prefs_);
-  registrar.Add(kName, &observer_);
+  registrar.Add(kName, observer_.GetCallback());
 
   // Changing the controlling store from default to user triggers notification.
-  observer_.Expect(&prefs_, kName, &default_value);
+  observer_.Expect(kName, &default_value);
   prefs_.Set(kName, default_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_CALL(observer_, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.Set(kName, default_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
   StringValue new_value(kValue);
-  observer_.Expect(&prefs_, kName, &new_value);
+  observer_.Expect(kName, &new_value);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
 TEST_F(PrefServiceSetValueTest, SetDictionaryValue) {
   prefs_.RegisterDictionaryPref(kName);
   PrefChangeRegistrar registrar;
   registrar.Init(&prefs_);
-  registrar.Add(kName, &observer_);
+  registrar.Add(kName, observer_.GetCallback());
 
-  EXPECT_CALL(observer_, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.RemoveUserPref(kName);
   Mock::VerifyAndClearExpectations(&observer_);
 
   DictionaryValue new_value;
   new_value.SetString(kName, kValue);
-  observer_.Expect(&prefs_, kName, &new_value);
+  observer_.Expect(kName, &new_value);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_CALL(observer_, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
   DictionaryValue empty;
-  observer_.Expect(&prefs_, kName, &empty);
+  observer_.Expect(kName, &empty);
   prefs_.Set(kName, empty);
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
 TEST_F(PrefServiceSetValueTest, SetListValue) {
   prefs_.RegisterListPref(kName);
   PrefChangeRegistrar registrar;
   registrar.Init(&prefs_);
-  registrar.Add(kName, &observer_);
+  registrar.Add(kName, observer_.GetCallback());
 
-  EXPECT_CALL(observer_, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.RemoveUserPref(kName);
   Mock::VerifyAndClearExpectations(&observer_);
 
   ListValue new_value;
   new_value.Append(Value::CreateStringValue(kValue));
-  observer_.Expect(&prefs_, kName, &new_value);
+  observer_.Expect(kName, &new_value);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_CALL(observer_, OnPreferenceChanged(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
   ListValue empty;
-  observer_.Expect(&prefs_, kName, &empty);
+  observer_.Expect(kName, &empty);
   prefs_.Set(kName, empty);
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
 class PrefServiceWebKitPrefs : public ChromeRenderViewHostTestHarness {
  protected:
   PrefServiceWebKitPrefs() : ui_thread_(BrowserThread::UI, &message_loop_) {
   }
 
   virtual void SetUp() {
@@ skipping 41 matching lines @@
   const char kDefaultFont[] = "Times";
 #elif defined(OS_CHROMEOS)
   const char kDefaultFont[] = "Tinos";
 #else
   const char kDefaultFont[] = "Times New Roman";
 #endif
   EXPECT_EQ(ASCIIToUTF16(kDefaultFont),
             webkit_prefs.standard_font_family_map[prefs::kWebKitCommonScript]);
   EXPECT_TRUE(webkit_prefs.javascript_enabled);
 }