sync: Implementation of Priority Preferences.

Priority preferences are similar to normal preferences but are never encrypted and are synced ahead of other datatypes. Because they're never encrypted, on first sync, they can be synced immediately after login, before the user is prompted for a passphrase.

Expected uses of priority preferences include hardware setting (eg. trackpad speed, scroll direction, etc.) as well as settings that could be 2-way synced with existing Google Account settings (eg. language).

BUG=168648


Review URL: https://chromiumcodereview.appspot.com/12033093

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@191047 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 41 insertions, 11 deletions

diff --git a/chrome/browser/prefs/pref_service_syncable.cc b/chrome/browser/prefs/pref_service_syncable.cc
index 8f2f867..b5e0267 100644
--- a/chrome/browser/prefs/pref_service_syncable.cc
+++ b/chrome/browser/prefs/pref_service_syncable.cc
@@ -43,21 +43,25 @@ PrefServiceSyncable::PrefServiceSyncable(
                 user_prefs,
                 pref_registry,
                 read_error_callback,
-                async) {
+                async),
+    pref_sync_associator_(syncer::PREFERENCES),
+    priority_pref_sync_associator_(syncer::PRIORITY_PREFERENCES) {
   pref_sync_associator_.SetPrefService(this);
+  priority_pref_sync_associator_.SetPrefService(this);
 
-  // Let PrefModelAssociator know about changes to preference values.
+  // Let PrefModelAssociators know about changes to preference values.
   pref_value_store->set_callback(
-      base::Bind(&PrefModelAssociator::ProcessPrefChange,
-                 base::Unretained(&pref_sync_associator_)));
+      base::Bind(&PrefServiceSyncable::ProcessPrefChange,
+                 base::Unretained(this)));
 
   // Add already-registered syncable preferences to PrefModelAssociator.
-  const std::set<std::string>& syncable_preferences =
+  const PrefRegistrySyncable::PrefToStatus& syncable_preferences =
       pref_registry->syncable_preferences();
-  for (std::set<std::string>::const_iterator it = syncable_preferences.begin();
+  for (PrefRegistrySyncable::PrefToStatus::const_iterator it =
+           syncable_preferences.begin();
        it != syncable_preferences.end();
        ++it) {
-    AddRegisteredSyncablePreference(it->c_str());
+    AddRegisteredSyncablePreference(it->first.c_str(), it->second);
   }
 
   // Watch for syncable preferences registered after this point.
@@ -106,6 +110,11 @@ bool PrefServiceSyncable::IsSyncing() {
   return pref_sync_associator_.models_associated();
 }
 
+
+bool PrefServiceSyncable::IsPrioritySyncing() {
+  return priority_pref_sync_associator_.models_associated();
+}
+
 void PrefServiceSyncable::AddObserver(PrefServiceSyncableObserver* observer) {
   observer_list_.AddObserver(observer);
 }
@@ -115,8 +124,16 @@ void PrefServiceSyncable::RemoveObserver(
   observer_list_.RemoveObserver(observer);
 }
 
-syncer::SyncableService* PrefServiceSyncable::GetSyncableService() {
-  return &pref_sync_associator_;
+syncer::SyncableService* PrefServiceSyncable::GetSyncableService(
+    const syncer::ModelType& type) {
+  if (type == syncer::PREFERENCES) {
+    return &pref_sync_associator_;
+  } else if (type == syncer::PRIORITY_PREFERENCES) {
+    return &priority_pref_sync_associator_;
+  } else {
+    NOTREACHED() << "invalid model type: " << type;
+    return NULL;
+  }
 }
 
 void PrefServiceSyncable::UpdateCommandLinePrefStore(
@@ -127,12 +144,25 @@ void PrefServiceSyncable::UpdateCommandLinePrefStore(
   PrefService::UpdateCommandLinePrefStore(cmd_line_store);
 }
 
-void PrefServiceSyncable::AddRegisteredSyncablePreference(const char* path) {
+void PrefServiceSyncable::AddRegisteredSyncablePreference(
+    const char* path,
+    const PrefRegistrySyncable::PrefSyncStatus sync_status) {
   DCHECK(FindPreference(path));
-  pref_sync_associator_.RegisterPref(path);
+  if (sync_status == PrefRegistrySyncable::SYNCABLE_PREF) {
+    pref_sync_associator_.RegisterPref(path);
+  } else if (sync_status == PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF) {
+    priority_pref_sync_associator_.RegisterPref(path);
+  } else {
+    NOTREACHED() << "invalid sync_status: " << sync_status;
+  }
 }
 
 void PrefServiceSyncable::OnIsSyncingChanged() {
   FOR_EACH_OBSERVER(PrefServiceSyncableObserver, observer_list_,
                     OnIsSyncingChanged());
 }
+
+void PrefServiceSyncable::ProcessPrefChange(const std::string& name) {
+  pref_sync_associator_.ProcessPrefChange(name);
+  priority_pref_sync_associator_.ProcessPrefChange(name);
+}