Remove dependency of PrefSyncableService on Profile.

chrome/browser/prefs/pref_service_syncable_unittest.cc

 // Copyright 2014 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/prefs/pref_service_syncable.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/grit/locale_settings.h"
+#include "chrome/browser/prefs/pref_model_associator_client.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/api/syncable_service.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/base/l10n/l10n_util.h"
 
 using syncer::SyncChange;
 using syncer::SyncData;
 
 namespace {
 const char kExampleUrl0[] = "http://example.com/0";
 const char kExampleUrl1[] = "http://example.com/1";
 const char kExampleUrl2[] = "http://example.com/2";
+
 const char kUnsyncedPreferenceName[] = "nonsense_pref_name";
 const char kUnsyncedPreferenceDefaultValue[] = "default";
 const char kNonDefaultCharsetValue[] = "foo";
+const char kDefaultCharsetValue[] = "utf-8";
+
+const char kDefaultCharset[] = "intl.charset_default";
+const char kHomePage[] = "homepage";
+const char kURLsToRestoreOnStartup[] = "session.startup_urls";
 }  // namespace
 
 class TestSyncProcessorStub : public syncer::SyncChangeProcessor {
  public:
   explicit TestSyncProcessorStub(syncer::SyncChangeList* output)
       : output_(output), fail_next_(false) {}
   syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) override {
     if (output_)
       output_->insert(output_->end(), change_list.begin(), change_list.end());
     if (fail_next_) {
       fail_next_ = false;
       return syncer::SyncError(
           FROM_HERE, syncer::SyncError::DATATYPE_ERROR, "Error",
           syncer::PREFERENCES);
     }
     return syncer::SyncError();
   }
 
-  void FailNextProcessSyncChanges() {
-    fail_next_ = true;
-  }
+  void FailNextProcessSyncChanges() { fail_next_ = true; }
 
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override {
     return syncer::SyncDataList();
   }
+
  private:
   syncer::SyncChangeList* output_;
   bool fail_next_;
 };
 
 class PrefServiceSyncableTest : public testing::Test {
  public:
   PrefServiceSyncableTest()
       : pref_sync_service_(NULL),
         test_processor_(NULL),
         next_pref_remote_sync_node_id_(0) {}
 
   void SetUp() override {
+    pref_model_associator_client_.RegisterPreference(
+        kURLsToRestoreOnStartup, PREF_MODEL_PREFERENCE_TYPE_LIST);
+    prefs_.SetPrefModelAssociatorClient(&pref_model_associator_client_);
+
     prefs_.registry()->RegisterStringPref(kUnsyncedPreferenceName,
                                           kUnsyncedPreferenceDefaultValue);
     prefs_.registry()->RegisterStringPref(
-        prefs::kHomePage,
+        kHomePage,
         std::string(),
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     prefs_.registry()->RegisterListPref(
-        prefs::kURLsToRestoreOnStartup,
+        kURLsToRestoreOnStartup,
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     prefs_.registry()->RegisterStringPref(
-        prefs::kDefaultCharset,
-        l10n_util::GetStringUTF8(IDS_DEFAULT_ENCODING),
+        kDefaultCharset,
+        kDefaultCharsetValue,
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 
     pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>(
         prefs_.GetSyncableService(syncer::PREFERENCES));
     ASSERT_TRUE(pref_sync_service_);
     next_pref_remote_sync_node_id_ = 0;
   }
 
-  syncer::SyncChange MakeRemoteChange(
-      int64 id,
-      const std::string& name,
-      const base::Value& value,
-      SyncChange::SyncChangeType type) {
+  syncer::SyncChange MakeRemoteChange(int64 id,
+                                      const std::string& name,
+                                      const base::Value& value,
+                                      SyncChange::SyncChangeType type) {
     std::string serialized;
     JSONStringValueSerializer json(&serialized);
     if (!json.Serialize(value))
       return syncer::SyncChange();
     sync_pb::EntitySpecifics entity;
     sync_pb::PreferenceSpecifics* pref_one = entity.mutable_preference();
     pref_one->set_name(name);
     pref_one->set_value(serialized);
     return syncer::SyncChange(
         FROM_HERE,
@@ skipping 39 matching lines @@
     InitWithSyncDataTakeOutput(syncer::SyncDataList(), NULL);
   }
 
   const base::Value& GetPreferenceValue(const std::string& name) {
     const PrefService::Preference* preference =
         prefs_.FindPreference(name.c_str());
     return *preference->GetValue();
   }
 
   scoped_ptr<base::Value> FindValue(const std::string& name,
-      const syncer::SyncChangeList& list) {
+                                    const syncer::SyncChangeList& list) {
     syncer::SyncChangeList::const_iterator it = list.begin();
     for (; it != list.end(); ++it) {
       if (syncer::SyncDataLocal(it->sync_data()).GetTag() == name) {
         return make_scoped_ptr(base::JSONReader::DeprecatedRead(
             it->sync_data().GetSpecifics().preference().value()));
       }
     }
     return scoped_ptr<base::Value>();
   }
 
   bool IsSynced(const std::string& pref_name) {
     return pref_sync_service_->registered_preferences().count(pref_name) > 0;
   }
 
   bool HasSyncData(const std::string& pref_name) {
     return pref_sync_service_->IsPrefSynced(pref_name);
   }
 
   PrefService* GetPrefs() { return &prefs_; }
   TestingPrefServiceSyncable* GetTestingPrefService() { return &prefs_; }
 
  protected:
+  PrefModelAssociatorClient pref_model_associator_client_;
   TestingPrefServiceSyncable prefs_;
 
   PrefModelAssociator* pref_sync_service_;
   TestSyncProcessorStub* test_processor_;
 
   // TODO(tim): Remove this by fixing AttachmentServiceProxyForTest.
   base::MessageLoop loop_;
 
   int next_pref_remote_sync_node_id_;
 };
 
 TEST_F(PrefServiceSyncableTest, CreatePrefSyncData) {
-  prefs_.SetString(prefs::kHomePage, kExampleUrl0);
+  prefs_.SetString(kHomePage, kExampleUrl0);
 
-  const PrefService::Preference* pref =
-      prefs_.FindPreference(prefs::kHomePage);
+  const PrefService::Preference* pref = prefs_.FindPreference(kHomePage);
   syncer::SyncData sync_data;
-  EXPECT_TRUE(pref_sync_service_->CreatePrefSyncData(pref->name(),
-      *pref->GetValue(), &sync_data));
-  EXPECT_EQ(std::string(prefs::kHomePage),
-            syncer::SyncDataLocal(sync_data).GetTag());
-  const sync_pb::PreferenceSpecifics& specifics(sync_data.GetSpecifics().
-      preference());
-  EXPECT_EQ(std::string(prefs::kHomePage), specifics.name());
+  EXPECT_TRUE(pref_sync_service_->CreatePrefSyncData(
+      pref->name(), *pref->GetValue(), &sync_data));
+  EXPECT_EQ(std::string(kHomePage), syncer::SyncDataLocal(sync_data).GetTag());
+  const sync_pb::PreferenceSpecifics& specifics(
+      sync_data.GetSpecifics().preference());
+  EXPECT_EQ(std::string(kHomePage), specifics.name());
 
   scoped_ptr<base::Value> value = base::JSONReader::Read(specifics.value());
   EXPECT_TRUE(pref->GetValue()->Equals(value.get()));
 }
 
 TEST_F(PrefServiceSyncableTest, ModelAssociationDoNotSyncDefaults) {
-  const PrefService::Preference* pref =
-      prefs_.FindPreference(prefs::kHomePage);
+  const PrefService::Preference* pref = prefs_.FindPreference(kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
 
-  EXPECT_TRUE(IsSynced(prefs::kHomePage));
+  EXPECT_TRUE(IsSynced(kHomePage));
   EXPECT_TRUE(pref->IsDefaultValue());
-  EXPECT_FALSE(FindValue(prefs::kHomePage, out).get());
+  EXPECT_FALSE(FindValue(kHomePage, out).get());
 }
 
 TEST_F(PrefServiceSyncableTest, ModelAssociationEmptyCloud) {
-  prefs_.SetString(prefs::kHomePage, kExampleUrl0);
+  prefs_.SetString(kHomePage, kExampleUrl0);
   {
-    ListPrefUpdate update(GetPrefs(), prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(GetPrefs(), kURLsToRestoreOnStartup);
     base::ListValue* url_list = update.Get();
     url_list->Append(new base::StringValue(kExampleUrl0));
     url_list->Append(new base::StringValue(kExampleUrl1));
   }
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
 
-  scoped_ptr<base::Value> value(FindValue(prefs::kHomePage, out));
+  scoped_ptr<base::Value> value(FindValue(kHomePage, out));
   ASSERT_TRUE(value.get());
-  EXPECT_TRUE(GetPreferenceValue(prefs::kHomePage).Equals(value.get()));
-  value = FindValue(prefs::kURLsToRestoreOnStartup, out).Pass();
+  EXPECT_TRUE(GetPreferenceValue(kHomePage).Equals(value.get()));
+  value = FindValue(kURLsToRestoreOnStartup, out).Pass();
   ASSERT_TRUE(value.get());
-  EXPECT_TRUE(
-      GetPreferenceValue(prefs::kURLsToRestoreOnStartup).Equals(value.get()));
+  EXPECT_TRUE(GetPreferenceValue(kURLsToRestoreOnStartup).Equals(value.get()));
 }
 
 TEST_F(PrefServiceSyncableTest, ModelAssociationCloudHasData) {
-  prefs_.SetString(prefs::kHomePage, kExampleUrl0);
+  prefs_.SetString(kHomePage, kExampleUrl0);
   {
-    ListPrefUpdate update(GetPrefs(), prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(GetPrefs(), kURLsToRestoreOnStartup);
     base::ListValue* url_list = update.Get();
     url_list->Append(new base::StringValue(kExampleUrl0));
     url_list->Append(new base::StringValue(kExampleUrl1));
   }
 
   syncer::SyncDataList in;
   syncer::SyncChangeList out;
-  AddToRemoteDataList(prefs::kHomePage, base::StringValue(kExampleUrl1), &in);
+  AddToRemoteDataList(kHomePage, base::StringValue(kExampleUrl1), &in);
   base::ListValue urls_to_restore;
   urls_to_restore.Append(new base::StringValue(kExampleUrl1));
   urls_to_restore.Append(new base::StringValue(kExampleUrl2));
-  AddToRemoteDataList(prefs::kURLsToRestoreOnStartup, urls_to_restore, &in);
-  AddToRemoteDataList(prefs::kDefaultCharset,
-                      base::StringValue(kNonDefaultCharsetValue),
-                      &in);
+  AddToRemoteDataList(kURLsToRestoreOnStartup, urls_to_restore, &in);
+  AddToRemoteDataList(kDefaultCharset,
+                      base::StringValue(kNonDefaultCharsetValue), &in);
   InitWithSyncDataTakeOutput(in, &out);
 
-  ASSERT_FALSE(FindValue(prefs::kHomePage, out).get());
-  ASSERT_FALSE(FindValue(prefs::kDefaultCharset, out).get());
+  ASSERT_FALSE(FindValue(kHomePage, out).get());
+  ASSERT_FALSE(FindValue(kDefaultCharset, out).get());
 
-  EXPECT_EQ(kExampleUrl1, prefs_.GetString(prefs::kHomePage));
+  EXPECT_EQ(kExampleUrl1, prefs_.GetString(kHomePage));
 
   scoped_ptr<base::ListValue> expected_urls(new base::ListValue);
   expected_urls->Append(new base::StringValue(kExampleUrl1));
   expected_urls->Append(new base::StringValue(kExampleUrl2));
   expected_urls->Append(new base::StringValue(kExampleUrl0));
-  scoped_ptr<base::Value> value(
-      FindValue(prefs::kURLsToRestoreOnStartup, out));
+  scoped_ptr<base::Value> value(FindValue(kURLsToRestoreOnStartup, out));
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(value->Equals(expected_urls.get()));
-  EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup).
-              Equals(expected_urls.get()));
-  EXPECT_EQ(kNonDefaultCharsetValue,
-            prefs_.GetString(prefs::kDefaultCharset));
+  EXPECT_TRUE(
+      GetPreferenceValue(kURLsToRestoreOnStartup).Equals(expected_urls.get()));
+  EXPECT_EQ(kNonDefaultCharsetValue, prefs_.GetString(kDefaultCharset));
 }
 
 TEST_F(PrefServiceSyncableTest, FailModelAssociation) {
   syncer::SyncChangeList output;
   TestSyncProcessorStub* stub = new TestSyncProcessorStub(&output);
   stub->FailNextProcessSyncChanges();
   syncer::SyncMergeResult r = pref_sync_service_->MergeDataAndStartSyncing(
       syncer::PREFERENCES, syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(stub),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new syncer::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
   EXPECT_TRUE(r.error().IsSet());
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedPreferenceWithDefaultValue) {
-  const PrefService::Preference* pref =
-      prefs_.FindPreference(prefs::kHomePage);
+  const PrefService::Preference* pref = prefs_.FindPreference(kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
   base::StringValue expected(kExampleUrl0);
-  GetPrefs()->Set(prefs::kHomePage, expected);
+  GetPrefs()->Set(kHomePage, expected);
 
-  scoped_ptr<base::Value> actual(FindValue(prefs::kHomePage, out));
+  scoped_ptr<base::Value> actual(FindValue(kHomePage, out));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(expected.Equals(actual.get()));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedPreferenceWithValue) {
-  GetPrefs()->SetString(prefs::kHomePage, kExampleUrl0);
+  GetPrefs()->SetString(kHomePage, kExampleUrl0);
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
   base::StringValue expected(kExampleUrl1);
-  GetPrefs()->Set(prefs::kHomePage, expected);
+  GetPrefs()->Set(kHomePage, expected);
 
-  scoped_ptr<base::Value> actual(FindValue(prefs::kHomePage, out));
+  scoped_ptr<base::Value> actual(FindValue(kHomePage, out));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(expected.Equals(actual.get()));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeActionUpdate) {
-  GetPrefs()->SetString(prefs::kHomePage, kExampleUrl0);
+  GetPrefs()->SetString(kHomePage, kExampleUrl0);
   InitWithNoSyncData();
 
   base::StringValue expected(kExampleUrl1);
   syncer::SyncChangeList list;
-  list.push_back(MakeRemoteChange(
-      1, prefs::kHomePage, expected, SyncChange::ACTION_UPDATE));
+  list.push_back(
+      MakeRemoteChange(1, kHomePage, expected, SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
-  const base::Value& actual = GetPreferenceValue(prefs::kHomePage);
+  const base::Value& actual = GetPreferenceValue(kHomePage);
   EXPECT_TRUE(expected.Equals(&actual));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeActionAdd) {
   InitWithNoSyncData();
 
   base::StringValue expected(kExampleUrl0);
   syncer::SyncChangeList list;
-  list.push_back(MakeRemoteChange(
-      1, prefs::kHomePage, expected, SyncChange::ACTION_ADD));
+  list.push_back(
+      MakeRemoteChange(1, kHomePage, expected, SyncChange::ACTION_ADD));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
-  const base::Value& actual = GetPreferenceValue(prefs::kHomePage);
+  const base::Value& actual = GetPreferenceValue(kHomePage);
   EXPECT_TRUE(expected.Equals(&actual));
-  EXPECT_EQ(1U,
-      pref_sync_service_->registered_preferences().count(prefs::kHomePage));
+  EXPECT_EQ(1U, pref_sync_service_->registered_preferences().count(kHomePage));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeUnknownPreference) {
   InitWithNoSyncData();
   syncer::SyncChangeList list;
   base::StringValue expected(kExampleUrl0);
   list.push_back(MakeRemoteChange(
       1, "unknown preference", expected, SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
   // Nothing interesting happens on the client when it gets an update
   // of an unknown preference.  We just should not crash.
 }
 
 TEST_F(PrefServiceSyncableTest, ManagedPreferences) {
   // Make the homepage preference managed.
   base::StringValue managed_value("http://example.com");
-  prefs_.SetManagedPref(prefs::kHomePage, managed_value.DeepCopy());
+  prefs_.SetManagedPref(kHomePage, managed_value.DeepCopy());
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
   // Changing the homepage preference should not sync anything.
   base::StringValue user_value("http://chromium..com");
-  prefs_.SetUserPref(prefs::kHomePage, user_value.DeepCopy());
+  prefs_.SetUserPref(kHomePage, user_value.DeepCopy());
   EXPECT_TRUE(out.empty());
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   base::StringValue sync_value("http://crbug.com");
   syncer::SyncChangeList list;
-  list.push_back(MakeRemoteChange(
-      1, prefs::kHomePage, sync_value, SyncChange::ACTION_UPDATE));
+  list.push_back(
+      MakeRemoteChange(1, kHomePage, sync_value, SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
-  EXPECT_TRUE(managed_value.Equals(prefs_.GetManagedPref(prefs::kHomePage)));
-  EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(prefs::kHomePage)));
+  EXPECT_TRUE(managed_value.Equals(prefs_.GetManagedPref(kHomePage)));
+  EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(kHomePage)));
 }
 
 // List preferences have special handling at association time due to our ability
 // to merge the local and sync value. Make sure the merge logic doesn't merge
 // managed preferences.
 TEST_F(PrefServiceSyncableTest, ManagedListPreferences) {
   // Make the list of urls to restore on startup managed.
   base::ListValue managed_value;
   managed_value.Append(new base::StringValue(kExampleUrl0));
   managed_value.Append(new base::StringValue(kExampleUrl1));
-  prefs_.SetManagedPref(prefs::kURLsToRestoreOnStartup,
-                         managed_value.DeepCopy());
+  prefs_.SetManagedPref(kURLsToRestoreOnStartup, managed_value.DeepCopy());
 
   // Set a cloud version.
   syncer::SyncDataList in;
   syncer::SyncChangeList out;
   base::ListValue urls_to_restore;
   urls_to_restore.Append(new base::StringValue(kExampleUrl1));
   urls_to_restore.Append(new base::StringValue(kExampleUrl2));
-  AddToRemoteDataList(prefs::kURLsToRestoreOnStartup, urls_to_restore, &in);
+  AddToRemoteDataList(kURLsToRestoreOnStartup, urls_to_restore, &in);
 
   // Start sync and verify the synced value didn't get merged.
   InitWithSyncDataTakeOutput(in, &out);
-  EXPECT_FALSE(FindValue(prefs::kURLsToRestoreOnStartup, out).get());
+  EXPECT_FALSE(FindValue(kURLsToRestoreOnStartup, out).get());
   out.clear();
 
   // Changing the user's urls to restore on startup pref should not sync
   // anything.
   base::ListValue user_value;
   user_value.Append(new base::StringValue("http://chromium.org"));
-  prefs_.SetUserPref(prefs::kURLsToRestoreOnStartup, user_value.DeepCopy());
-  EXPECT_FALSE(FindValue(prefs::kURLsToRestoreOnStartup, out).get());
+  prefs_.SetUserPref(kURLsToRestoreOnStartup, user_value.DeepCopy());
+  EXPECT_FALSE(FindValue(kURLsToRestoreOnStartup, out).get());
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   base::ListValue sync_value;
   sync_value.Append(new base::StringValue("http://crbug.com"));
   syncer::SyncChangeList list;
-  list.push_back(MakeRemoteChange(
-      1, prefs::kURLsToRestoreOnStartup, sync_value,
-      SyncChange::ACTION_UPDATE));
+  list.push_back(MakeRemoteChange(1, kURLsToRestoreOnStartup, sync_value,
+                                  SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
-  EXPECT_TRUE(managed_value.Equals(
-          prefs_.GetManagedPref(prefs::kURLsToRestoreOnStartup)));
-  EXPECT_TRUE(sync_value.Equals(
-          prefs_.GetUserPref(prefs::kURLsToRestoreOnStartup)));
+  EXPECT_TRUE(
+      managed_value.Equals(prefs_.GetManagedPref(kURLsToRestoreOnStartup)));
+  EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(kURLsToRestoreOnStartup)));
 }
 
 TEST_F(PrefServiceSyncableTest, DynamicManagedPreferences) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
   base::StringValue initial_value("http://example.com/initial");
-  GetPrefs()->Set(prefs::kHomePage, initial_value);
-  scoped_ptr<base::Value> actual(FindValue(prefs::kHomePage, out));
+  GetPrefs()->Set(kHomePage, initial_value);
+  scoped_ptr<base::Value> actual(FindValue(kHomePage, out));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(initial_value.Equals(actual.get()));
 
   // Switch kHomePage to managed and set a different value.
   base::StringValue managed_value("http://example.com/managed");
-  GetTestingPrefService()->SetManagedPref(prefs::kHomePage,
-                                                    managed_value.DeepCopy());
+  GetTestingPrefService()->SetManagedPref(kHomePage, managed_value.DeepCopy());
 
   // The pref value should be the one dictated by policy.
-  EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(prefs::kHomePage)));
+  EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kHomePage)));
 
   // Switch kHomePage back to unmanaged.
-  GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
+  GetTestingPrefService()->RemoveManagedPref(kHomePage);
 
   // The original value should be picked up.
-  EXPECT_TRUE(initial_value.Equals(&GetPreferenceValue(prefs::kHomePage)));
+  EXPECT_TRUE(initial_value.Equals(&GetPreferenceValue(kHomePage)));
 }
 
 TEST_F(PrefServiceSyncableTest, DynamicManagedPreferencesWithSyncChange) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
   base::StringValue initial_value("http://example.com/initial");
-  GetPrefs()->Set(prefs::kHomePage, initial_value);
-  scoped_ptr<base::Value> actual(FindValue(prefs::kHomePage, out));
+  GetPrefs()->Set(kHomePage, initial_value);
+  scoped_ptr<base::Value> actual(FindValue(kHomePage, out));
   EXPECT_TRUE(initial_value.Equals(actual.get()));
 
   // Switch kHomePage to managed and set a different value.
   base::StringValue managed_value("http://example.com/managed");
-  GetTestingPrefService()->SetManagedPref(prefs::kHomePage,
-                                                    managed_value.DeepCopy());
+  GetTestingPrefService()->SetManagedPref(kHomePage, managed_value.DeepCopy());
 
   // Change the sync value.
   base::StringValue sync_value("http://example.com/sync");
   syncer::SyncChangeList list;
-  list.push_back(MakeRemoteChange(
-      1, prefs::kHomePage, sync_value, SyncChange::ACTION_UPDATE));
+  list.push_back(
+      MakeRemoteChange(1, kHomePage, sync_value, SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
   // The pref value should still be the one dictated by policy.
-  EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(prefs::kHomePage)));
+  EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kHomePage)));
 
   // Switch kHomePage back to unmanaged.
-  GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
+  GetTestingPrefService()->RemoveManagedPref(kHomePage);
 
   // Sync value should be picked up.
-  EXPECT_TRUE(sync_value.Equals(&GetPreferenceValue(prefs::kHomePage)));
+  EXPECT_TRUE(sync_value.Equals(&GetPreferenceValue(kHomePage)));
 }
 
 TEST_F(PrefServiceSyncableTest, DynamicManagedDefaultPreferences) {
-  const PrefService::Preference* pref =
-      prefs_.FindPreference(prefs::kHomePage);
+  const PrefService::Preference* pref = prefs_.FindPreference(kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
 
-  EXPECT_TRUE(IsSynced(prefs::kHomePage));
+  EXPECT_TRUE(IsSynced(kHomePage));
   EXPECT_TRUE(pref->IsDefaultValue());
-  EXPECT_FALSE(FindValue(prefs::kHomePage, out).get());
+  EXPECT_FALSE(FindValue(kHomePage, out).get());
   out.clear();
 
   // Switch kHomePage to managed and set a different value.
   base::StringValue managed_value("http://example.com/managed");
-  GetTestingPrefService()->SetManagedPref(prefs::kHomePage,
-                                          managed_value.DeepCopy());
+  GetTestingPrefService()->SetManagedPref(kHomePage, managed_value.DeepCopy());
   // The pref value should be the one dictated by policy.
-  EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(prefs::kHomePage)));
+  EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kHomePage)));
   EXPECT_FALSE(pref->IsDefaultValue());
   // There should be no synced value.
-  EXPECT_FALSE(FindValue(prefs::kHomePage, out).get());
+  EXPECT_FALSE(FindValue(kHomePage, out).get());
   // Switch kHomePage back to unmanaged.
-  GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
+  GetTestingPrefService()->RemoveManagedPref(kHomePage);
   // The original value should be picked up.
   EXPECT_TRUE(pref->IsDefaultValue());
   // There should still be no synced value.
-  EXPECT_FALSE(FindValue(prefs::kHomePage, out).get());
+  EXPECT_FALSE(FindValue(kHomePage, out).get());
 }
 
 TEST_F(PrefServiceSyncableTest, DeletePreference) {
-  prefs_.SetString(prefs::kHomePage, kExampleUrl0);
-  const PrefService::Preference* pref =
-      prefs_.FindPreference(prefs::kHomePage);
+  prefs_.SetString(kHomePage, kExampleUrl0);
+  const PrefService::Preference* pref = prefs_.FindPreference(kHomePage);
   EXPECT_FALSE(pref->IsDefaultValue());
 
   InitWithNoSyncData();
 
   scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
   syncer::SyncChangeList list;
-  list.push_back(MakeRemoteChange(
-      1, prefs::kHomePage, *null_value, SyncChange::ACTION_DELETE));
+  list.push_back(
+      MakeRemoteChange(1, kHomePage, *null_value, SyncChange::ACTION_DELETE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(pref->IsDefaultValue());
 }