sync: Implementation of Priority Preferences.

chrome/browser/prefs/pref_model_associator.cc

Index: chrome/browser/prefs/pref_model_associator.cc
diff --git a/chrome/browser/prefs/pref_model_associator.cc b/chrome/browser/prefs/pref_model_associator.cc
index 6773c2c3eb98a06419b67fd99d79e57e77761edf..078c0d84409ee137957d731fd8016dd95acc1892 100644
--- a/chrome/browser/prefs/pref_model_associator.cc
+++ b/chrome/browser/prefs/pref_model_associator.cc
@@ -21,12 +21,15 @@
 #include "sync/protocol/sync.pb.h"
 
 using syncer::PREFERENCES;
+using syncer::PRIORITY_PREFERENCES;
 
-PrefModelAssociator::PrefModelAssociator()
+PrefModelAssociator::PrefModelAssociator(syncer::ModelType type)
     : models_associated_(false),
       processing_syncer_changes_(false),
-      pref_service_(NULL) {
+      pref_service_(NULL),
+      type_(type) {
   DCHECK(CalledOnValidThread());
+  DCHECK(type_ == PREFERENCES || type_ == PRIORITY_PREFERENCES);
 }
 
 PrefModelAssociator::~PrefModelAssociator() {
@@ -43,12 +46,17 @@ void PrefModelAssociator::InitPrefAndAssociate(
   VLOG(1) << "Associating preference " << pref_name;
 
   if (sync_pref.IsValid()) {
-    const sync_pb::PreferenceSpecifics& preference =
-        sync_pref.GetSpecifics().preference();
-    DCHECK_EQ(pref_name, preference.name());
+    const sync_pb::PreferenceSpecifics* preference;
+
+    if (type_ == PREFERENCES) {

[Nicolas Zea, 2013/02/25 23:47:47]

Yeah, I think an anon namespace helper function would be useful for this logic,
e.g. GetSpecificsForPreference(&preference)

[albertb, 2013/03/01 22:01:56]

Done.

+      preference = &sync_pref.GetSpecifics().preference();
+    } else {
+      preference = &sync_pref.GetSpecifics().priority_preference().preference();
+    }
+    DCHECK_EQ(pref_name, preference->name());
 
     base::JSONReader reader;
-    scoped_ptr<Value> sync_value(reader.ReadToValue(preference.value()));
+    scoped_ptr<Value> sync_value(reader.ReadToValue(preference->value()));
     if (!sync_value.get()) {
       LOG(ERROR) << "Failed to deserialize preference value: "
                  << reader.GetErrorMessage();
@@ -67,7 +75,7 @@ void PrefModelAssociator::InitPrefAndAssociate(
         LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
         pref_service_->ClearPref(pref_name.c_str());
       } else if (!new_value->IsType(user_pref_value->GetType())) {
-        LOG(WARNING) << "Synced value for " << preference.name()
+        LOG(WARNING) << "Synced value for " << preference->name()
                      << " is of type " << new_value->GetType()
                      << " which doesn't match pref type "
                      << user_pref_value->GetType();
@@ -124,7 +132,7 @@ syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing(
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
-  DCHECK_EQ(type, PREFERENCES);
+  DCHECK_EQ(type_, type);
   DCHECK(CalledOnValidThread());
   DCHECK(pref_service_);
   DCHECK(!sync_processor_.get());
@@ -143,8 +151,15 @@ syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing(
            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();
+    DCHECK_EQ(type_, sync_iter->GetDataType());
+    std::string sync_pref_name;
+
+    if (type_ == PREFERENCES) {
+      sync_pref_name = sync_iter->GetSpecifics().preference().name();
+    } else {
+      sync_pref_name =
+          sync_iter->GetSpecifics().priority_preference().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
@@ -178,7 +193,7 @@ syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing(
 }
 
 void PrefModelAssociator::StopSyncing(syncer::ModelType type) {
-  DCHECK_EQ(type, PREFERENCES);
+  DCHECK_EQ(type_, type);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
@@ -205,7 +220,7 @@ scoped_ptr<Value> PrefModelAssociator::MergePreference(
 bool PrefModelAssociator::CreatePrefSyncData(
     const std::string& name,
     const Value& value,
-    syncer::SyncData* sync_data) {
+    syncer::SyncData* sync_data) const {
   if (value.IsType(Value::TYPE_NULL)) {
     LOG(ERROR) << "Attempting to sync a null pref value for " << name;
     return false;
@@ -221,9 +236,18 @@ bool PrefModelAssociator::CreatePrefSyncData(
   }
 
   sync_pb::EntitySpecifics specifics;
-  sync_pb::PreferenceSpecifics* pref_specifics = specifics.mutable_preference();
+  sync_pb::PreferenceSpecifics* pref_specifics;
+
+  if (type_ == PREFERENCES) {
+    pref_specifics = specifics.mutable_preference();
+  } else {
+    pref_specifics =
+        specifics.mutable_priority_preference()->mutable_preference();
+  }
+
   pref_specifics->set_name(name);
   pref_specifics->set_value(serialized);
+
   *sync_data = syncer::SyncData::CreateLocalData(name, name, specifics);
   return true;
 }
@@ -293,7 +317,7 @@ Value* PrefModelAssociator::MergeDictionaryValues(
 syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
     syncer::ModelType type)
     const {
-  DCHECK_EQ(PREFERENCES, type);
+  DCHECK_EQ(type_, type);
   syncer::SyncDataList current_data;
   for (PreferenceSet::const_iterator iter = synced_preferences_.begin();
        iter != synced_preferences_.end();
@@ -325,11 +349,16 @@ syncer::SyncError PrefModelAssociator::ProcessSyncChanges(
   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(PREFERENCES, iter->sync_data().GetDataType());
+    DCHECK_EQ(type_, iter->sync_data().GetDataType());
 
     std::string name;
-    sync_pb::PreferenceSpecifics pref_specifics =
-        iter->sync_data().GetSpecifics().preference();
+    sync_pb::PreferenceSpecifics pref_specifics;
+    if (type_ == PREFERENCES) {
+      pref_specifics = iter->sync_data().GetSpecifics().preference();
+    } else {
+      pref_specifics =
+          iter->sync_data().GetSpecifics().priority_preference().preference();
+    }
     scoped_ptr<Value> value(ReadPreferenceSpecifics(pref_specifics,
                                                     &name));