[Sync] Rename csync namespace to syncer

chrome/browser/prefs/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 "chrome/browser/prefs/pref_model_associator.h"
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
@@ skipping 15 matching lines @@
       pref_service_(NULL) {
   DCHECK(CalledOnValidThread());
 }
 
 PrefModelAssociator::~PrefModelAssociator() {
   DCHECK(CalledOnValidThread());
   pref_service_ = NULL;
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
-    const csync::SyncData& sync_pref,
+    const syncer::SyncData& sync_pref,
     const std::string& pref_name,
-    csync::SyncChangeList* sync_changes) {
+    syncer::SyncChangeList* sync_changes) {
   const PrefService::Preference* pref =
       pref_service_->FindPreference(pref_name.c_str());
   DCHECK(pref);
   VLOG(1) << "Associating preference " << pref_name;
 
   base::JSONReader reader;
   if (sync_pref.IsValid()) {
     // The server has a value for the preference, we have to reconcile it with
     // ours.
     const sync_pb::PreferenceSpecifics& preference =
@@ skipping 18 matching lines @@
     } else if (!new_value->IsType(pref->GetType())) {
       LOG(WARNING) << "Synced value for " << preference.name()
                    << " is of type " << new_value->GetType()
                    << " which doesn't match pref type " << pref->GetType();
     } else if (!pref->GetValue()->Equals(new_value.get())) {
       pref_service_->Set(pref_name.c_str(), *new_value);
     }
 
     // If the merge resulted in an updated value, inform the syncer.
     if (!value->Equals(new_value.get())) {
-      csync::SyncData sync_data;
+      syncer::SyncData sync_data;
       if (!CreatePrefSyncData(pref->name(), *new_value, &sync_data)) {
         LOG(ERROR) << "Failed to update preference.";
         return;
       }
       sync_changes->push_back(
-          csync::SyncChange(csync::SyncChange::ACTION_UPDATE, sync_data));
+          syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
     }
   } else if (pref->IsUserControlled()) {
     // The server does not know about this preference and should be added
     // to the syncer's database.
-    csync::SyncData sync_data;
+    syncer::SyncData sync_data;
     if (!CreatePrefSyncData(pref->name(), *pref->GetValue(), &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
     sync_changes->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_ADD, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_ADD, sync_data));
   } 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.
     return;
   }
 
   // Make sure we add it to our list of synced preferences so we know what
   // the server is aware of.
   synced_preferences_.insert(pref_name);
   return;
 }
 
-csync::SyncError PrefModelAssociator::MergeDataAndStartSyncing(
+syncer::SyncError PrefModelAssociator::MergeDataAndStartSyncing(
     syncable::ModelType type,
-    const csync::SyncDataList& initial_sync_data,
-    scoped_ptr<csync::SyncChangeProcessor> sync_processor,
-    scoped_ptr<csync::SyncErrorFactory> sync_error_factory) {
+    const syncer::SyncDataList& initial_sync_data,
+    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
+    scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK_EQ(type, PREFERENCES);
   DCHECK(CalledOnValidThread());
   DCHECK(pref_service_);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
-  csync::SyncChangeList new_changes;
+  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 (csync::SyncDataList::const_iterator sync_iter =
+  for (syncer::SyncDataList::const_iterator sync_iter =
            initial_sync_data.begin();
        sync_iter != initial_sync_data.end();
        ++sync_iter) {
     DCHECK_EQ(PREFERENCES, sync_iter->GetDataType());
     std::string sync_pref_name = sync_iter->GetSpecifics().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 it's 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) {
-    InitPrefAndAssociate(csync::SyncData(), *pref_name_iter, &new_changes);
+    InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
 
   // Push updates to sync.
-  csync::SyncError error =
+  syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   if (error.IsSet()) {
     return error;
   }
 
   models_associated_ = true;
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 void PrefModelAssociator::StopSyncing(syncable::ModelType type) {
   DCHECK_EQ(type, PREFERENCES);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
 }
 
 Value* PrefModelAssociator::MergePreference(
@@ skipping 12 matching lines @@
     return MergeDictionaryValues(*local_pref.GetValue(), server_value);
   }
 
   // If this is not a specially handled preference, server wins.
   return server_value.DeepCopy();
 }
 
 bool PrefModelAssociator::CreatePrefSyncData(
     const std::string& name,
     const Value& value,
-    csync::SyncData* sync_data) {
+    syncer::SyncData* sync_data) {
   std::string serialized;
   // TODO(zea): consider JSONWriter::Write since you don't have to check
   // failures to deserialize.
   JSONStringValueSerializer json(&serialized);
   if (!json.Serialize(value)) {
     LOG(ERROR) << "Failed to serialize preference value.";
     return false;
   }
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::PreferenceSpecifics* pref_specifics = specifics.mutable_preference();
   pref_specifics->set_name(name);
   pref_specifics->set_value(serialized);
-  *sync_data = csync::SyncData::CreateLocalData(name, name, specifics);
+  *sync_data = syncer::SyncData::CreateLocalData(name, name, specifics);
   return true;
 }
 
 Value* PrefModelAssociator::MergeListValues(const Value& from_value,
                                             const Value& to_value) {
   if (from_value.GetType() == Value::TYPE_NULL)
     return to_value.DeepCopy();
   if (to_value.GetType() == Value::TYPE_NULL)
     return from_value.DeepCopy();
 
@@ skipping 45 matching lines @@
       result->SetWithoutPathExpansion(*key, from_value->DeepCopy());
     }
   }
   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.
-csync::SyncDataList PrefModelAssociator::GetAllSyncData(
+syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
     syncable::ModelType type)
     const {
   DCHECK_EQ(PREFERENCES, type);
-  csync::SyncDataList current_data;
+  syncer::SyncDataList current_data;
   for (PreferenceSet::const_iterator iter = synced_preferences_.begin();
        iter != synced_preferences_.end();
        ++iter) {
     std::string name = *iter;
     const PrefService::Preference* pref =
       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.
-    csync::SyncData sync_data;
+    syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data))
       continue;
     current_data.push_back(sync_data);
   }
   return current_data;
 }
 
-csync::SyncError PrefModelAssociator::ProcessSyncChanges(
+syncer::SyncError PrefModelAssociator::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const csync::SyncChangeList& change_list) {
+    const syncer::SyncChangeList& change_list) {
   if (!models_associated_) {
-    csync::SyncError error(FROM_HERE,
+    syncer::SyncError error(FROM_HERE,
                     "Models not yet associated.",
                     PREFERENCES);
     return error;
   }
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
-  csync::SyncChangeList::const_iterator iter;
+  syncer::SyncChangeList::const_iterator iter;
   for (iter = change_list.begin(); iter != change_list.end(); ++iter) {
     DCHECK_EQ(PREFERENCES, iter->sync_data().GetDataType());
 
     std::string name;
     sync_pb::PreferenceSpecifics pref_specifics =
         iter->sync_data().GetSpecifics().preference();
     scoped_ptr<Value> value(ReadPreferenceSpecifics(pref_specifics,
                                                     &name));
 
-    if (iter->change_type() == csync::SyncChange::ACTION_DELETE) {
+    if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
       // We never delete preferences.
       NOTREACHED() << "Attempted to process sync delete change for " << name
                    << ". Skipping.";
       continue;
     }
 
     // Skip values we can't deserialize.
     // TODO(zea): consider taking some further action such as erasing the bad
     // data.
     if (!value.get())
@@ skipping 10 matching lines @@
     const PrefService::Preference* pref =
         pref_service_->FindPreference(pref_name);
     DCHECK(pref);
 
     // This will only modify the user controlled value store, which takes
     // priority over the default value but is ignored if the preference is
     // policy controlled.
     pref_service_->Set(pref_name, *value);
 
     // Keep track of any newly synced preferences.
-    if (iter->change_type() == csync::SyncChange::ACTION_ADD) {
+    if (iter->change_type() == syncer::SyncChange::ACTION_ADD) {
       synced_preferences_.insert(name);
     }
   }
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 Value* PrefModelAssociator::ReadPreferenceSpecifics(
     const sync_pb::PreferenceSpecifics& preference,
     std::string* name) {
   base::JSONReader reader;
   scoped_ptr<Value> value(reader.ReadToValue(preference.value()));
   if (!value.get()) {
     std::string err = "Failed to deserialize preference value: " +
         reader.GetErrorMessage();
@@ skipping 31 matching lines @@
     return;
 
   const PrefService::Preference* preference =
       pref_service_->FindPreference(name.c_str());
   if (!preference)
     return;
 
   if (!IsPrefRegistered(name.c_str()))
     return;  // We are not syncing this preference.
 
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
 
   if (!preference->IsUserModifiable()) {
     // If the preference is no longer user modifiable, it must now be controlled
     // by policy, whose values we do not sync. Just return. If the preference
     // stops being controlled by policy, it will revert back to the user value
     // (which we continue to update with sync changes).
     return;
   }
 
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   if (synced_preferences_.count(name) == 0) {
     // Not in synced_preferences_ means no synced data. InitPrefAndAssociate(..)
     // 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(csync::SyncData(), name, &changes);
+    InitPrefAndAssociate(syncer::SyncData(), name, &changes);
   } else {
     // We are already syncing this preference, just update it's sync node.
-    csync::SyncData sync_data;
+    syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
     changes.push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_UPDATE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
   }
 
-  csync::SyncError error =
+  syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void PrefModelAssociator::SetPrefService(PrefService* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }