[Sync] Rename syncable_prefs to sync_preferences.

components/sync_preferences/pref_model_associator.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync/model/sync_change.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/protocol/preference_specifics.pb.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/syncable_prefs/pref_model_associator_client.h"
-#include "components/syncable_prefs/pref_service_syncable.h"
+#include "components/sync_preferences/pref_model_associator_client.h"
+#include "components/sync_preferences/pref_service_syncable.h"
 
 using syncer::PREFERENCES;
 using syncer::PRIORITY_PREFERENCES;
 
-namespace syncable_prefs {
+namespace sync_preferences {
 
 namespace {
 
 const sync_pb::PreferenceSpecifics& GetSpecifics(const syncer::SyncData& pref) {
   DCHECK(pref.GetDataType() == syncer::PREFERENCES ||
          pref.GetDataType() == syncer::PRIORITY_PREFERENCES);
   if (pref.GetDataType() == syncer::PRIORITY_PREFERENCES) {
     return pref.GetSpecifics().priority_preference().preference();
   } else {
     return pref.GetSpecifics().preference();
@@ skipping 30 matching lines @@
   DCHECK(CalledOnValidThread());
   pref_service_ = NULL;
 
   synced_pref_observers_.clear();
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
     const syncer::SyncData& sync_pref,
     const std::string& pref_name,
     syncer::SyncChangeList* sync_changes) {
-  const base::Value* user_pref_value = pref_service_->GetUserPrefValue(
-      pref_name.c_str());
+  const base::Value* user_pref_value =
+      pref_service_->GetUserPrefValue(pref_name.c_str());
   VLOG(1) << "Associating preference " << pref_name;
 
   if (sync_pref.IsValid()) {
     const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref);
     DCHECK(pref_name == preference.name());
     base::JSONReader reader;
     std::unique_ptr<base::Value> sync_value(
         reader.ReadToValue(preference.value()));
     if (!sync_value.get()) {
       LOG(ERROR) << "Failed to deserialize preference value: "
@@ skipping 23 matching lines @@
       }
 
       // If the merge resulted in an updated value, inform the syncer.
       if (!sync_value->Equals(new_value.get())) {
         syncer::SyncData sync_data;
         if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) {
           LOG(ERROR) << "Failed to update preference.";
           return;
         }
 
-        sync_changes->push_back(
-          syncer::SyncChange(FROM_HERE,
-                             syncer::SyncChange::ACTION_UPDATE,
-                             sync_data));
+        sync_changes->push_back(syncer::SyncChange(
+            FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
       }
     } else if (!sync_value->IsType(base::Value::TYPE_NULL)) {
       // Only a server value exists. Just set the local user value.
       pref_service_->Set(pref_name.c_str(), *sync_value);
     } else {
       LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
     }
     synced_preferences_.insert(preference.name());
   } else if (user_pref_value) {
     // The server does not know about this preference and should be added
     // to the syncer's database.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(pref_name, *user_pref_value, &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
-    sync_changes->push_back(
-        syncer::SyncChange(FROM_HERE,
-                           syncer::SyncChange::ACTION_ADD,
-                           sync_data));
+    sync_changes->push_back(syncer::SyncChange(
+        FROM_HERE, syncer::SyncChange::ACTION_ADD, sync_data));
     synced_preferences_.insert(pref_name);
   }
 
   // Else this pref does not have a sync value but also does not have a user
   // controlled value (either it's a default value or it's policy controlled,
   // either way it's not interesting). We can ignore it. Once it gets changed,
   // we'll send the new user controlled value to the syncer.
 }
 
 void PrefModelAssociator::RegisterMergeDataFinishedCallback(
@@ skipping 19 matching lines @@
   sync_processor_ = std::move(sync_processor);
   sync_error_factory_ = std::move(sync_error_factory);
 
   syncer::SyncChangeList new_changes;
   std::set<std::string> remaining_preferences = registered_preferences_;
 
   // Go through and check for all preferences we care about that sync already
   // knows about.
   for (syncer::SyncDataList::const_iterator sync_iter =
            initial_sync_data.begin();
-       sync_iter != initial_sync_data.end();
-       ++sync_iter) {
+       sync_iter != initial_sync_data.end(); ++sync_iter) {
     DCHECK_EQ(type_, sync_iter->GetDataType());
 
     const sync_pb::PreferenceSpecifics& preference = GetSpecifics(*sync_iter);
     std::string sync_pref_name = preference.name();
 
     if (remaining_preferences.count(sync_pref_name) == 0) {
       // We're not syncing this preference locally, ignore the sync data.
       // TODO(zea): Eventually we want to be able to have the syncable service
       // reconstruct all sync data for its datatype (therefore having
       // GetAllSyncData be a complete representation). We should store this
       // data somewhere, even if we don't use it.
       continue;
     }
 
     remaining_preferences.erase(sync_pref_name);
     InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes);
   }
 
   // Go through and build sync data for any remaining preferences.
   for (std::set<std::string>::iterator pref_name_iter =
-          remaining_preferences.begin();
-       pref_name_iter != remaining_preferences.end();
-       ++pref_name_iter) {
+           remaining_preferences.begin();
+       pref_name_iter != remaining_preferences.end(); ++pref_name_iter) {
     InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
 
   // Push updates to sync.
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 
   for (const auto& callback : callback_list_)
@@ skipping 114 matching lines @@
     }
   }
   return result;
 }
 
 // Note: This will build a model of all preferences registered as syncable
 // with user controlled data. We do not track any information for preferences
 // not registered locally as syncable and do not inform the syncer of
 // non-user controlled preferences.
 syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
-    syncer::ModelType type)
-    const {
+    syncer::ModelType type) const {
   DCHECK_EQ(type_, type);
   syncer::SyncDataList current_data;
   for (PreferenceSet::const_iterator iter = synced_preferences_.begin();
-       iter != synced_preferences_.end();
-       ++iter) {
+       iter != synced_preferences_.end(); ++iter) {
     std::string name = *iter;
     const PrefService::Preference* pref =
-      pref_service_->FindPreference(name.c_str());
+        pref_service_->FindPreference(name.c_str());
     DCHECK(pref);
     if (!pref->IsUserControlled() || pref->IsDefaultValue())
       continue;  // This is not data we care about.
     // TODO(zea): plumb a way to read the user controlled value.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data))
       continue;
     current_data.push_back(sync_data);
   }
   return current_data;
 }
 
 syncer::SyncError PrefModelAssociator::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   if (!models_associated_) {
-    syncer::SyncError error(FROM_HERE,
-                            syncer::SyncError::DATATYPE_ERROR,
-                            "Models not yet associated.",
-                            PREFERENCES);
+    syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
+                            "Models not yet associated.", PREFERENCES);
     return error;
   }
   base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
   syncer::SyncChangeList::const_iterator iter;
   for (iter = change_list.begin(); iter != change_list.end(); ++iter) {
     DCHECK_EQ(type_, iter->sync_data().GetDataType());
 
     const sync_pb::PreferenceSpecifics& pref_specifics =
         GetSpecifics(iter->sync_data());
 
@@ skipping 32 matching lines @@
     }
   }
   return syncer::SyncError();
 }
 
 base::Value* PrefModelAssociator::ReadPreferenceSpecifics(
     const sync_pb::PreferenceSpecifics& preference) {
   base::JSONReader reader;
   std::unique_ptr<base::Value> value(reader.ReadToValue(preference.value()));
   if (!value.get()) {
-    std::string err = "Failed to deserialize preference value: " +
-        reader.GetErrorMessage();
+    std::string err =
+        "Failed to deserialize preference value: " + reader.GetErrorMessage();
     LOG(ERROR) << err;
     return NULL;
   }
   return value.release();
 }
 
 bool PrefModelAssociator::IsPrefSynced(const std::string& name) const {
   return synced_preferences_.find(name) != synced_preferences_.end();
 }
 
 void PrefModelAssociator::AddSyncedPrefObserver(const std::string& name,
-    SyncedPrefObserver* observer) {
+                                                SyncedPrefObserver* observer) {
   std::unique_ptr<SyncedPrefObserverList>& observers =
       synced_pref_observers_[name];
   if (!observers)
     observers = base::MakeUnique<SyncedPrefObserverList>();
 
   observers->AddObserver(observer);
 }
 
-void PrefModelAssociator::RemoveSyncedPrefObserver(const std::string& name,
+void PrefModelAssociator::RemoveSyncedPrefObserver(
+    const std::string& name,
     SyncedPrefObserver* observer) {
   auto observer_iter = synced_pref_observers_.find(name);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second.get();
   observers->RemoveObserver(observer);
 }
 
 void PrefModelAssociator::SetPrefModelAssociatorClientForTesting(
     const PrefModelAssociatorClient* client) {
@@ skipping 49 matching lines @@
     // will determine if we care about its data (e.g. if it has a default value
     // and hasn't been changed yet we don't) and take care syncing any new data.
     InitPrefAndAssociate(syncer::SyncData(), name, &changes);
   } else {
     // We are already syncing this preference, just update it's sync node.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
-    changes.push_back(
-        syncer::SyncChange(FROM_HERE,
-                           syncer::SyncChange::ACTION_UPDATE,
-                           sync_data));
+    changes.push_back(syncer::SyncChange(
+        FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
   }
 
   syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }
 
 void PrefModelAssociator::NotifySyncedPrefObservers(const std::string& path,
                                                     bool from_sync) const {
   auto observer_iter = synced_pref_observers_.find(path);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second.get();
   for (auto& observer : *observers)
     observer.OnSyncedPrefChanged(path, from_sync);
 }
 
-}  // namespace syncable_prefs
+}  // namespace sync_preferences