Split PrefService into PrefService, PrefServiceSimple and PrefServiceSyncable.

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/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(PrefService* prefs) {
-  prefs->RegisterBooleanPref(kBoolPref, false, PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterIntegerPref(kIntPref, 0, PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterDoublePref(kDoublePref, 0.0, PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(kStringPref,
-                            "default",
-                            PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(kStringListPref,
-                          new ListValue(),
-                          PrefService::UNSYNCABLE_PREF);
+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());
 }
 
 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 55 matching lines @@
   StringPrefMember str_;
   int observe_cnt_;
 
  private:
   PrefService* prefs_;
 };
 
 }  // anonymous namespace
 
 TEST(PrefMemberTest, BasicGetAndSet) {
-  TestingPrefService prefs;
+  TestingPrefServiceSimple prefs;
   RegisterTestPrefs(&prefs);
 
   // 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 @@
   EXPECT_EQ(expected_vector, vector);
 
   // 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.
-  TestingPrefService prefs;
+  TestingPrefServiceSimple prefs;
   RegisterTestPrefs(&prefs);
 
   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) {
-  TestingPrefService prefs;
+  TestingPrefServiceSimple prefs;
   RegisterTestPrefs(&prefs);
 
   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));
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(2, test_obj.observe_cnt_);
   EXPECT_EQ("hello", prefs.GetString(kStringPref));
 }
 
 TEST(PrefMemberTest, NoInit) {
   // Make sure not calling Init on a PrefMember doesn't cause problems.
   IntegerPrefMember pref;
 }
 
 TEST(PrefMemberTest, MoveToThread) {
-  TestingPrefService prefs;
+  TestingPrefServiceSimple prefs;
   scoped_refptr<GetPrefValueHelper> helper(new GetPrefValueHelper());
   RegisterTestPrefs(&prefs);
   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();
 }