[Sync] Rename syncable_prefs to sync_preferences.

components/sync_preferences/pref_model_associator_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 "components/syncable_prefs/pref_model_associator.h"
+#include "components/sync_preferences/pref_model_associator.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "components/prefs/scoped_user_pref_update.h"
-#include "components/syncable_prefs/pref_model_associator_client.h"
-#include "components/syncable_prefs/pref_service_mock_factory.h"
-#include "components/syncable_prefs/pref_service_syncable.h"
+#include "components/sync_preferences/pref_model_associator_client.h"
+#include "components/sync_preferences/pref_service_mock_factory.h"
+#include "components/sync_preferences/pref_service_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncable_prefs {
+namespace sync_preferences {
 
 namespace {
 
 const char kStringPrefName[] = "pref.string";
 const char kListPrefName[] = "pref.list";
 const char kDictionaryPrefName[] = "pref.dictionary";
 
 class TestPrefModelAssociatorClient : public PrefModelAssociatorClient {
  public:
   TestPrefModelAssociatorClient() {}
@@ skipping 14 matching lines @@
 };
 
 class AbstractPreferenceMergeTest : public testing::Test {
  protected:
   AbstractPreferenceMergeTest() {
     PrefServiceMockFactory factory;
     factory.SetPrefModelAssociatorClient(&client_);
     scoped_refptr<user_prefs::PrefRegistrySyncable> pref_registry(
         new user_prefs::PrefRegistrySyncable);
     pref_registry->RegisterStringPref(
-        kStringPrefName,
-        std::string(),
+        kStringPrefName, std::string(),
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     pref_registry->RegisterListPref(
-        kListPrefName,
-        user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+        kListPrefName, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     pref_registry->RegisterDictionaryPref(
-        kDictionaryPrefName,
-        user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+        kDictionaryPrefName, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     pref_service_ = factory.CreateSyncable(pref_registry.get());
     pref_sync_service_ = static_cast<PrefModelAssociator*>(
         pref_service_->GetSyncableService(syncer::PREFERENCES));
   }
 
   void SetContentPattern(base::DictionaryValue* patterns_dict,
                          const std::string& expression,
                          int setting) {
     base::DictionaryValue* expression_dict;
-    bool found =
-        patterns_dict->GetDictionaryWithoutPathExpansion(expression,
-                                                         &expression_dict);
+    bool found = patterns_dict->GetDictionaryWithoutPathExpansion(
+        expression, &expression_dict);
     if (!found) {
       expression_dict = new base::DictionaryValue;
       patterns_dict->SetWithoutPathExpansion(expression, expression_dict);
     }
     expression_dict->SetWithoutPathExpansion(
         "setting", new base::FundamentalValue(setting));
   }
 
   void SetPrefToEmpty(const std::string& pref_name) {
     std::unique_ptr<base::Value> empty_value;
@@ skipping 59 matching lines @@
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->AppendString(local_url0_);
   }
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), *null_value));
   const base::ListValue* local_list_value =
-        pref_service_->GetList(kListPrefName);
+      pref_service_->GetList(kListPrefName);
   EXPECT_TRUE(merged_value->Equals(local_list_value));
 }
 
 TEST_F(ListPreferenceMergeTest, ServerEmpty) {
   std::unique_ptr<base::Value> empty_value(new base::ListValue);
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->AppendString(local_url0_);
   }
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), *empty_value));
   const base::ListValue* local_list_value =
-        pref_service_->GetList(kListPrefName);
+      pref_service_->GetList(kListPrefName);
   EXPECT_TRUE(merged_value->Equals(local_list_value));
 }
 
 TEST_F(ListPreferenceMergeTest, Merge) {
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->AppendString(local_url0_);
     local_list_value->AppendString(local_url1_);
   }
@@ skipping 254 matching lines @@
   base::ListValue server_url_list_;
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(IndividualPreferenceMergeTest, ListPreference) {
   EXPECT_TRUE(MergeListPreference(kListPrefName));
 }
 
 }  // namespace
 
-}  // namespace syncable_prefs
+}  // namespace sync_preferences