Adjust preference sync code to only sync user modifiable preferences.

chrome/browser/pref_service_unittest.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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 <string>
 
 #include "app/test/data/resource.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/dummy_pref_store.h"
-#include "chrome/browser/pref_service.h"
 #include "chrome/browser/pref_value_store.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/notification_observer_mock.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/test/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Mock;
 using testing::Pointee;
 using testing::Property;
 
 class TestPrefObserver : public NotificationObserver {
  public:
@@ skipping 29 matching lines @@
  private:
   bool observer_fired_;
   const PrefService* prefs_;
   const std::wstring pref_name_;
   std::string new_pref_value_;
 };
 
 // TODO(port): port this test to POSIX.
 #if defined(OS_WIN)
 TEST(PrefServiceTest, LocalizedPrefs) {
-  PrefService prefs(new PrefValueStore(NULL, NULL, NULL, new DummyPrefStore(),
-      NULL));
+  TestingPrefService prefs;
   const wchar_t kBoolean[] = L"boolean";
   const wchar_t kInteger[] = L"integer";
   const wchar_t kString[] = L"string";
   prefs.RegisterLocalizedBooleanPref(kBoolean, IDS_LOCALE_BOOL);
   prefs.RegisterLocalizedIntegerPref(kInteger, IDS_LOCALE_INT);
   prefs.RegisterLocalizedStringPref(kString, IDS_LOCALE_STRING);
 
   // The locale default should take preference over the user default.
   EXPECT_FALSE(prefs.GetBoolean(kBoolean));
   EXPECT_EQ(1, prefs.GetInteger(kInteger));
   EXPECT_EQ("hello", prefs.GetString(kString));
 
   prefs.SetBoolean(kBoolean, true);
   EXPECT_TRUE(prefs.GetBoolean(kBoolean));
   prefs.SetInteger(kInteger, 5);
   EXPECT_EQ(5, prefs.GetInteger(kInteger));
   prefs.SetString(kString, "foo");
   EXPECT_EQ("foo", prefs.GetString(kString));
 }
 #endif
 
 TEST(PrefServiceTest, NoObserverFire) {
-  PrefService prefs(new PrefValueStore(NULL, NULL, NULL, new DummyPrefStore(),
-      NULL));
+  TestingPrefService prefs;
 
   const wchar_t pref_name[] = L"homepage";
   prefs.RegisterStringPref(pref_name, "");
 
   const std::string new_pref_value("http://www.google.com/");
   TestPrefObserver obs(&prefs, pref_name, new_pref_value);
   prefs.AddPrefObserver(pref_name, &obs);
   // This should fire the checks in TestPrefObserver::Observe.
   prefs.SetString(pref_name, new_pref_value);
 
@@ skipping 14 matching lines @@
   // Clearing the pref again should not cause the pref to fire.
   obs.Reset("");
   prefs.ClearPref(pref_name);
   EXPECT_FALSE(obs.observer_fired());
 
   // Ok, clean up.
   prefs.RemovePrefObserver(pref_name, &obs);
 }
 
 TEST(PrefServiceTest, HasPrefPath) {
-  PrefService prefs(new PrefValueStore(NULL, NULL, NULL, new DummyPrefStore(),
-      NULL));
+  TestingPrefService prefs;
 
   const wchar_t path[] = L"fake.path";
 
   // Shouldn't initially have a path.
   EXPECT_FALSE(prefs.HasPrefPath(path));
 
   // Register the path. This doesn't set a value, so the path still shouldn't
   // exist.
   prefs.RegisterStringPref(path, std::string());
   EXPECT_FALSE(prefs.HasPrefPath(path));
 
   // Set a value and make sure we have a path.
   prefs.SetString(path, "blah");
   EXPECT_TRUE(prefs.HasPrefPath(path));
 }
 
 TEST(PrefServiceTest, Observers) {
   const wchar_t pref_name[] = L"homepage";
 
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetString(pref_name, std::string("http://www.cnn.com"));
-  DummyPrefStore* pref_store = new DummyPrefStore();
-  pref_store->set_prefs(dict);
-  PrefService prefs(new PrefValueStore(NULL, NULL, NULL, pref_store, NULL));
+  TestingPrefService prefs;
+  prefs.SetUserPref(pref_name, Value::CreateStringValue(L"http://www.cnn.com"));
   prefs.RegisterStringPref(pref_name, "");
 
   const std::string new_pref_value("http://www.google.com/");
   TestPrefObserver obs(&prefs, pref_name, new_pref_value);
   prefs.AddPrefObserver(pref_name, &obs);
   // This should fire the checks in TestPrefObserver::Observe.
   prefs.SetString(pref_name, new_pref_value);
 
   // Make sure the tests were actually run.
   EXPECT_TRUE(obs.observer_fired());
@@ skipping 20 matching lines @@
   // Ok, clean up.
   prefs.RemovePrefObserver(pref_name, &obs2);
 }
 
 class PrefServiceSetValueTest : public testing::Test {
  protected:
   static const wchar_t name_[];
   static const char value_[];
 
   PrefServiceSetValueTest()
-      : prefs_(new PrefValueStore(NULL, NULL, NULL, new DummyPrefStore(),
-               NULL)),
-        name_string_(name_),
+      : name_string_(name_),
         null_value_(Value::CreateNullValue()) {}
 
   void SetExpectNoNotification() {
     EXPECT_CALL(observer_, Observe(_, _, _)).Times(0);
   }
 
   void SetExpectPrefChanged() {
     EXPECT_CALL(observer_,
                 Observe(NotificationType(NotificationType::PREF_CHANGED), _,
                         Property(&Details<std::wstring>::ptr,
                                  Pointee(name_string_))));
   }
 
-  PrefService prefs_;
+  TestingPrefService prefs_;
   std::wstring name_string_;
   scoped_ptr<Value> null_value_;
   NotificationObserverMock observer_;
 };
 
 const wchar_t PrefServiceSetValueTest::name_[] = L"name";
 const char PrefServiceSetValueTest::value_[] = "value";
 
 TEST_F(PrefServiceSetValueTest, SetStringValue) {
   const char default_string[] = "default";
@@ skipping 68 matching lines @@
   Mock::VerifyAndClearExpectations(&observer_);
 
   SetExpectPrefChanged();
   prefs_.Set(name_, *null_value_);
   Mock::VerifyAndClearExpectations(&observer_);
   list = prefs_.GetMutableList(name_);
   EXPECT_EQ(0U, list->GetSize());
 
   prefs_.RemovePrefObserver(name_, &observer_);
 }