sync: Implementation of Priority Preferences.

chrome/browser/prefs/pref_service_syncable.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_service_syncable.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/prefs/default_pref_store.h"
 #include "base/prefs/overlay_user_pref_store.h"
@@ skipping 25 matching lines @@
     PersistentPrefStore* user_prefs,
     PrefRegistrySyncable* pref_registry,
     base::Callback<void(PersistentPrefStore::PrefReadError)>
         read_error_callback,
     bool async)
   : PrefService(pref_notifier,
                 pref_value_store,
                 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.
   pref_registry->SetSyncableRegistrationCallback(
       base::Bind(&PrefServiceSyncable::AddRegisteredSyncablePreference,
                  base::Unretained(this)));
 }
 
 PrefServiceSyncable::~PrefServiceSyncable() {
   // Remove our callback from the registry, since it may outlive us.
@@ skipping 24 matching lines @@
           NULL,  // recommended
           forked_registry->defaults(),
           pref_notifier),
       incognito_pref_store,
       forked_registry,
       read_error_callback_,
       false);
   return incognito_service;
 }
 
 bool PrefServiceSyncable::IsSyncing() {

[tim (not reviewing), 2013/03/21 16:36:00]

This isn't going to work properly...  This is the mechanism (along with
PrefServiceObserver) that lets client code tell whether prefs have finished
model association yet and when that happens, which is important in certain
contexts (e.g https://codereview.chromium.org/11233049/), and we may need it for
priority prefs too (at the very least, it's not clear at all what IsSyncing
covers now).    

[Mattias Nissler (ping if slow), 2013/03/21 16:59:40]

FWIW, I consider this whole IsSyncing() call a hack. It seems like it was added
to support the case of pref consumers doing special logic on first sync. That's
something that could be implemented in better ways, e.g. allowing pref consumers
to register custom callbacks for merging incoming sync data with existing prefs.

[albertb, 2013/03/21 17:10:33]

Done.

[albertb, 2013/03/21 17:10:33]

I updated the condition to also check priority prefs. Or are you suggesting that
there should be two IsSyncing methods instead?

[tim (not reviewing), 2013/03/21 18:10:55]

@albert - well, that won't work if you want to know when priority prefs have
synced, which is likely more useful than "normal prefs" -- in fact, I think we
might only want to care about priority prefs and change the "normal prefs" that
fall into this "must happen quickly", like the one in the linked CL, bucket to
be priority.  For now though, maybe just have two methods and a TODO.

@mnissler - one example is on Chrome OS, we'd like to avoid showing the
avatar-picker screen altogether if sync pulls down a choice the user made on
another device (which will be stored in a pref). The thinking is to use this
observer to signal. Can you explain what you were thinking in this context? 
(Happy to follow up offline / in email, we probably shouldn't change it with
this CL :P).

[albertb, 2013/03/21 18:46:29]

Done.

   return pref_sync_associator_.models_associated();
 }
 
 void PrefServiceSyncable::AddObserver(PrefServiceSyncableObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void PrefServiceSyncable::RemoveObserver(
     PrefServiceSyncableObserver* observer) {
   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(
     PrefStore* cmd_line_store) {
   // If |pref_service_forked_| is true, then this PrefService and the forked
   // copies will be out of sync.
   DCHECK(!pref_service_forked_);
   PrefService::UpdateCommandLinePrefStore(cmd_line_store);
 }
 
-void PrefServiceSyncable::AddRegisteredSyncablePreference(const char* path) {
+void PrefServiceSyncable::AddRegisteredSyncablePreference(
+    const char* path, const PrefRegistrySyncable::PrefSyncStatus sync_status) {

[Mattias Nissler (ping if slow), 2013/03/21 06:50:15]

nit: parameter decls on separate lines

[albertb, 2013/03/21 17:10:33]

Done.

   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);
+}