sync: Implementation of Priority Preferences.

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"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #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() {
   DCHECK(CalledOnValidThread());
   pref_service_ = NULL;
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
     const syncer::SyncData& sync_pref,
     const std::string& pref_name,
@@ skipping 77 matching lines @@
   // the server is aware of.
   synced_preferences_.insert(pref_name);
   return;
 }
 
 syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing(
     syncer::ModelType type,
     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());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   syncer::SyncMergeResult merge_result(type);
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
   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) {
-    DCHECK_EQ(PREFERENCES, sync_iter->GetDataType());
+    DCHECK_EQ(type_, 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;
     }
 
@@ skipping 14 matching lines @@
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 
   models_associated_ = true;
   pref_service_->OnIsSyncingChanged();
   return merge_result;
 }
 
 void PrefModelAssociator::StopSyncing(syncer::ModelType type) {
-  DCHECK_EQ(type, PREFERENCES);
+  DCHECK_EQ(type_, type);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
   pref_service_->OnIsSyncingChanged();
 }
 
 scoped_ptr<Value> PrefModelAssociator::MergePreference(
     const std::string& name,
     const Value& local_value,
     const Value& server_value) {
   if (name == prefs::kURLsToRestoreOnStartup) {
     return scoped_ptr<Value>(MergeListValues(local_value, server_value)).Pass();
   }
 
   if (name == prefs::kContentSettingsPatternPairs) {
     return scoped_ptr<Value>(
         MergeDictionaryValues(local_value, server_value)).Pass();
   }
 
   // If this is not a specially handled preference, server wins.
   return scoped_ptr<Value>(server_value.DeepCopy()).Pass();
 }
 
 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;
   }
 
   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();
+  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;
 }
 
 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 49 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 {
-  DCHECK_EQ(PREFERENCES, type);
+  DCHECK_EQ(type_, type);
   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.
@@ skipping 11 matching lines @@
     const syncer::SyncChangeList& change_list) {
   if (!models_associated_) {
     syncer::SyncError error(FROM_HERE,
                     "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(PREFERENCES, iter->sync_data().GetDataType());
+    DCHECK_EQ(type_, iter->sync_data().GetDataType());
 
     std::string name;
     sync_pb::PreferenceSpecifics pref_specifics =

[Nicolas Zea, 2013/02/21 23:41:11]

nit:prefer an if/else here based on type

[albertb, 2013/02/22 20:08:47]

Done.

         iter->sync_data().GetSpecifics().preference();
+    if (type_ == PRIORITY_PREFERENCES) {
+      pref_specifics =
+          iter->sync_data().GetSpecifics().priority_preference().preference();
+    }
     scoped_ptr<Value> value(ReadPreferenceSpecifics(pref_specifics,
                                                     &name));
 
     if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
       // We never delete preferences.
       NOTREACHED() << "Attempted to process sync delete change for " << name
                    << ". Skipping.";
       continue;
     }
 
@@ skipping 77 matching lines @@
   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;
   }
 
   base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
+  LOG(ERROR) << "synced pref(" << type_ << ") change: " << name;

[Nicolas Zea, 2013/02/21 23:41:11]

did you mean to live this?

[albertb, 2013/02/22 20:08:47]

Done.

   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(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));
   }
 
   syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }