Convert PrefSyncStatus into PrefRegistrationFlags

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 37 matching lines @@
     priority_pref_sync_associator_(syncer::PRIORITY_PREFERENCES) {
   pref_sync_associator_.SetPrefService(this);
   priority_pref_sync_associator_.SetPrefService(this);
 
   // Let PrefModelAssociators know about changes to preference values.
   pref_value_store->set_callback(
       base::Bind(&PrefServiceSyncable::ProcessPrefChange,
                  base::Unretained(this)));
 
   // Add already-registered syncable preferences to PrefModelAssociator.
-  const user_prefs::PrefRegistrySyncable::PrefToStatus& syncable_preferences =
-      pref_registry->syncable_preferences();
-  for (user_prefs::PrefRegistrySyncable::PrefToStatus::const_iterator it =
-           syncable_preferences.begin();
-       it != syncable_preferences.end();
-       ++it) {
-    AddRegisteredSyncablePreference(it->first.c_str(), it->second);
-  }
+  for (const auto& entry : pref_registry->registration_flags())
+    AddRegisteredSyncablePreference(entry.first.c_str(), entry.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.
   user_prefs::PrefRegistrySyncable* registry =
@@ skipping 79 matching lines @@
   priority_pref_sync_associator_.AddSyncedPrefObserver(name, observer);
 }
 
 void PrefServiceSyncable::RemoveSyncedPrefObserver(
     const std::string& name,
     SyncedPrefObserver* observer) {
   pref_sync_associator_.RemoveSyncedPrefObserver(name, observer);
   priority_pref_sync_associator_.RemoveSyncedPrefObserver(name, observer);
 }
 
-void PrefServiceSyncable::AddRegisteredSyncablePreference(
-    const char* path,
-    const user_prefs::PrefRegistrySyncable::PrefSyncStatus sync_status) {
+void PrefServiceSyncable::AddRegisteredSyncablePreference(const char* path,
+                                                          uint32 flags) {
   DCHECK(FindPreference(path));
-  if (sync_status == user_prefs::PrefRegistrySyncable::SYNCABLE_PREF) {
+  if (flags & user_prefs::PrefRegistrySyncable::SYNCABLE_PREF) {
     pref_sync_associator_.RegisterPref(path);
-  } else if (sync_status ==
+  } else if (flags &
              user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF) {
     priority_pref_sync_associator_.RegisterPref(path);
   } else {
-    NOTREACHED() << "invalid sync_status: " << sync_status;
+    NOTREACHED() << "invalid sync flag";

[Mattias Nissler (ping if slow), 2015/04/20 09:33:34]

This is no longer appropriate after your code change in lines 58-59, as this may
now get invoked for prefs that are not marked as syncable.

[raymes, 2015/04/21 07:58:54]

Ahh good catch, done.

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