Remove PrefServiceSimple, replacing it with PrefService and PrefRegistrySimple.

base/prefs/public/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 "base/prefs/public/pref_member.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
+#include "chrome/browser/prefs/pref_registry_simple.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kBoolPref[] = "bool";
 const char kIntPref[] = "int";
 const char kDoublePref[] = "double";
 const char kStringPref[] = "string";
 const char kStringListPref[] = "string_list";
 
-void RegisterTestPrefs(PrefServiceSimple* prefs) {
-  prefs->RegisterBooleanPref(kBoolPref, false);
-  prefs->RegisterIntegerPref(kIntPref, 0);
-  prefs->RegisterDoublePref(kDoublePref, 0.0);
-  prefs->RegisterStringPref(kStringPref, "default");
-  prefs->RegisterListPref(kStringListPref, new ListValue());
+void RegisterTestPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterBooleanPref(kBoolPref, false);
+  registry->RegisterIntegerPref(kIntPref, 0);
+  registry->RegisterDoublePref(kDoublePref, 0.0);
+  registry->RegisterStringPref(kStringPref, "default");
+  registry->RegisterListPref(kStringListPref, new ListValue());
 }
 
 class GetPrefValueHelper
     : public base::RefCountedThreadSafe<GetPrefValueHelper> {
  public:
   GetPrefValueHelper() : value_(false), pref_thread_("pref thread") {
     pref_thread_.Start();
   }
 
   void Init(const char* pref_name, PrefService* prefs) {
@@ skipping 56 matching lines @@
   int observe_cnt_;
 
  private:
   PrefService* prefs_;
 };
 
 }  // anonymous namespace
 
 TEST(PrefMemberTest, BasicGetAndSet) {
   TestingPrefServiceSimple prefs;
-  RegisterTestPrefs(&prefs);
+  RegisterTestPrefs(prefs.registry());
 
   // Test bool
   BooleanPrefMember boolean;
   boolean.Init(kBoolPref, &prefs);
 
   // Check the defaults
   EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
   EXPECT_FALSE(boolean.GetValue());
   EXPECT_FALSE(*boolean);
 
@@ skipping 125 matching lines @@
 
   // Now try to add an invalid list.  |vector| should not be changed.
   list.AppendInteger(0);
   EXPECT_FALSE(subtle::PrefMemberVectorStringUpdate(list, &vector));
   EXPECT_EQ(expected_vector, vector);
 }
 
 TEST(PrefMemberTest, TwoPrefs) {
   // Make sure two DoublePrefMembers stay in sync.
   TestingPrefServiceSimple prefs;
-  RegisterTestPrefs(&prefs);
+  RegisterTestPrefs(prefs.registry());
 
   DoublePrefMember pref1;
   pref1.Init(kDoublePref, &prefs);
   DoublePrefMember pref2;
   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);
 }
 
 TEST(PrefMemberTest, Observer) {
   TestingPrefServiceSimple prefs;
-  RegisterTestPrefs(&prefs);
+  RegisterTestPrefs(prefs.registry());
 
   PrefMemberTestClass test_obj(&prefs);
   EXPECT_EQ("default", *test_obj.str_);
 
   // Calling SetValue should not fire the observer.
   test_obj.str_.SetValue("hello");
   EXPECT_EQ(0, test_obj.observe_cnt_);
   EXPECT_EQ("hello", prefs.GetString(kStringPref));
 
   // Changing the pref does fire the observer.
@@ skipping 12 matching lines @@
 }
 
 TEST(PrefMemberTest, NoInit) {
   // Make sure not calling Init on a PrefMember doesn't cause problems.
   IntegerPrefMember pref;
 }
 
 TEST(PrefMemberTest, MoveToThread) {
   TestingPrefServiceSimple prefs;
   scoped_refptr<GetPrefValueHelper> helper(new GetPrefValueHelper());
-  RegisterTestPrefs(&prefs);
+  RegisterTestPrefs(prefs.registry());
   helper->Init(kBoolPref, &prefs);
 
   helper->FetchValue();
   EXPECT_FALSE(helper->value());
 
   prefs.SetBoolean(kBoolPref, true);
 
   helper->FetchValue();
   EXPECT_TRUE(helper->value());
 
   helper->Destroy();
 
   helper->FetchValue();
   EXPECT_TRUE(helper->value());
 
   helper->StopThread();
 }