Remove the last usages of PrefObserver outside of Prefs.

chrome/browser/api/prefs/pref_member_unittest.cc

 // Copyright (c) 2011 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/api/prefs/pref_member.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 24 matching lines @@
                           new ListValue(),
                           PrefService::UNSYNCABLE_PREF);
 }
 
 class GetPrefValueCallback
     : public base::RefCountedThreadSafe<GetPrefValueCallback> {
  public:
   GetPrefValueCallback() : value_(false) {}
 
   void Init(const char* pref_name, PrefService* prefs) {
-    pref_.Init(pref_name, prefs, NULL);
+    pref_.Init(pref_name, prefs);
     pref_.MoveToThread(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
   }
 
   void Destroy() {
     pref_.Destroy();
   }
 
   bool FetchValue() {
     if (!BrowserThread::PostTask(
@@ skipping 14 matching lines @@
   void GetPrefValueOnIOThread() {
     value_ = pref_.GetValue();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             MessageLoop::QuitClosure());
   }
 
   BooleanPrefMember pref_;
   bool value_;
 };
 
-class PrefMemberTestClass : public PrefObserver {
+class PrefMemberTestClass {
  public:
   explicit PrefMemberTestClass(PrefService* prefs)
       : observe_cnt_(0), prefs_(prefs) {
-    str_.Init(kStringPref, prefs, this);
+    str_.Init(kStringPref, prefs,
+              base::Bind(&PrefMemberTestClass::OnPreferenceChanged,
+                         base::Unretained(this)));
   }
 
-  virtual void OnPreferenceChanged(PrefServiceBase* service,
-                                   const std::string& pref_name) OVERRIDE {
-    EXPECT_EQ(service, prefs_);
+  void OnPreferenceChanged(const std::string& pref_name) {
     EXPECT_EQ(pref_name, kStringPref);
     EXPECT_EQ(str_.GetValue(), prefs_->GetString(kStringPref));
     ++observe_cnt_;
   }
 
   StringPrefMember str_;
   int observe_cnt_;
 
  private:
   PrefService* prefs_;
 };
 
 }  // anonymous namespace
 
 TEST(PrefMemberTest, BasicGetAndSet) {
   TestingPrefService prefs;
   RegisterTestPrefs(&prefs);
 
   // Test bool
   BooleanPrefMember boolean;
-  boolean.Init(kBoolPref, &prefs, NULL);
+  boolean.Init(kBoolPref, &prefs);
 
   // Check the defaults
   EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
   EXPECT_FALSE(boolean.GetValue());
   EXPECT_FALSE(*boolean);
 
   // Try changing through the member variable.
   boolean.SetValue(true);
   EXPECT_TRUE(boolean.GetValue());
   EXPECT_TRUE(prefs.GetBoolean(kBoolPref));
   EXPECT_TRUE(*boolean);
 
   // Try changing back through the pref.
   prefs.SetBoolean(kBoolPref, false);
   EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
   EXPECT_FALSE(boolean.GetValue());
   EXPECT_FALSE(*boolean);
 
   // Test int
   IntegerPrefMember integer;
-  integer.Init(kIntPref, &prefs, NULL);
+  integer.Init(kIntPref, &prefs);
 
   // Check the defaults
   EXPECT_EQ(0, prefs.GetInteger(kIntPref));
   EXPECT_EQ(0, integer.GetValue());
   EXPECT_EQ(0, *integer);
 
   // Try changing through the member variable.
   integer.SetValue(5);
   EXPECT_EQ(5, integer.GetValue());
   EXPECT_EQ(5, prefs.GetInteger(kIntPref));
   EXPECT_EQ(5, *integer);
 
   // Try changing back through the pref.
   prefs.SetInteger(kIntPref, 2);
   EXPECT_EQ(2, prefs.GetInteger(kIntPref));
   EXPECT_EQ(2, integer.GetValue());
   EXPECT_EQ(2, *integer);
 
   // Test double
   DoublePrefMember double_member;
-  double_member.Init(kDoublePref, &prefs, NULL);
+  double_member.Init(kDoublePref, &prefs);
 
   // Check the defaults
   EXPECT_EQ(0.0, prefs.GetDouble(kDoublePref));
   EXPECT_EQ(0.0, double_member.GetValue());
   EXPECT_EQ(0.0, *double_member);
 
   // Try changing through the member variable.
   double_member.SetValue(1.0);
   EXPECT_EQ(1.0, double_member.GetValue());
   EXPECT_EQ(1.0, prefs.GetDouble(kDoublePref));
   EXPECT_EQ(1.0, *double_member);
 
   // Try changing back through the pref.
   prefs.SetDouble(kDoublePref, 3.0);
   EXPECT_EQ(3.0, prefs.GetDouble(kDoublePref));
   EXPECT_EQ(3.0, double_member.GetValue());
   EXPECT_EQ(3.0, *double_member);
 
   // Test string
   StringPrefMember string;
-  string.Init(kStringPref, &prefs, NULL);
+  string.Init(kStringPref, &prefs);
 
   // Check the defaults
   EXPECT_EQ("default", prefs.GetString(kStringPref));
   EXPECT_EQ("default", string.GetValue());
   EXPECT_EQ("default", *string);
 
   // Try changing through the member variable.
   string.SetValue("foo");
   EXPECT_EQ("foo", string.GetValue());
   EXPECT_EQ("foo", prefs.GetString(kStringPref));
   EXPECT_EQ("foo", *string);
 
   // Try changing back through the pref.
   prefs.SetString(kStringPref, "bar");
   EXPECT_EQ("bar", prefs.GetString(kStringPref));
   EXPECT_EQ("bar", string.GetValue());
   EXPECT_EQ("bar", *string);
 
   // Test string list
   ListValue expected_list;
   std::vector<std::string> expected_vector;
   StringListPrefMember string_list;
-  string_list.Init(kStringListPref, &prefs, NULL);
+  string_list.Init(kStringListPref, &prefs);
 
   // Check the defaults
   EXPECT_TRUE(expected_list.Equals(prefs.GetList(kStringListPref)));
   EXPECT_EQ(expected_vector, string_list.GetValue());
   EXPECT_EQ(expected_vector, *string_list);
 
   // Try changing through the pref member.
   expected_list.AppendString("foo");
   expected_vector.push_back("foo");
   string_list.SetValue(expected_vector);
@@ skipping 38 matching lines @@
   EXPECT_FALSE(subtle::PrefMemberVectorStringUpdate(list, &vector));
   EXPECT_EQ(expected_vector, vector);
 }
 
 TEST(PrefMemberTest, TwoPrefs) {
   // Make sure two DoublePrefMembers stay in sync.
   TestingPrefService prefs;
   RegisterTestPrefs(&prefs);
 
   DoublePrefMember pref1;
-  pref1.Init(kDoublePref, &prefs, NULL);
+  pref1.Init(kDoublePref, &prefs);
   DoublePrefMember pref2;
-  pref2.Init(kDoublePref, &prefs, NULL);
+  pref2.Init(kDoublePref, &prefs);
 
   pref1.SetValue(2.3);
   EXPECT_EQ(2.3, *pref2);
 
   pref2.SetValue(3.5);
   EXPECT_EQ(3.5, *pref1);
 
   prefs.SetDouble(kDoublePref, 4.2);
   EXPECT_EQ(4.2, *pref1);
   EXPECT_EQ(4.2, *pref2);
@@ skipping 48 matching lines @@
   prefs.SetBoolean(kBoolPref, true);
 
   ASSERT_TRUE(callback->FetchValue());
   EXPECT_TRUE(callback->value());
 
   callback->Destroy();
 
   ASSERT_TRUE(callback->FetchValue());
   EXPECT_TRUE(callback->value());
 }