Introduce PrefRegistrySyncable, simplifying PrefServiceSyncable.

chrome/browser/sync/sync_prefs.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNC_PREFS_H_
 #define CHROME_BROWSER_SYNC_SYNC_PREFS_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/prefs/public/pref_member.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 
-class PrefServiceSyncable;
+class PrefRegistrySyncable;
+class PrefService;
 class ProfileIOData;
 
 namespace browser_sync {
 
 class SyncPrefObserver {
  public:
   // Called whenever the pref that controls whether sync is managed
   // changes.
   virtual void OnSyncManagedPrefChange(bool is_sync_managed) = 0;
 
@@ skipping 13 matching lines @@
 //   sync_setup_flow.cc
 //   sync_setup_wizard.cc
 //   sync_setup_wizard_unittest.cc
 //   two_client_preferences_sync_test.cc
 class SyncPrefs : NON_EXPORTED_BASE(public base::NonThreadSafe),
                   public base::SupportsWeakPtr<SyncPrefs> {
  public:
   // |pref_service| may be NULL (for unit tests), but in that case no
   // setter methods should be called.  Does not take ownership of
   // |pref_service|.
-  explicit SyncPrefs(PrefServiceSyncable* pref_service);
+  explicit SyncPrefs(PrefService* pref_service);
 
   virtual ~SyncPrefs();
 
-  static void RegisterUserPrefs(PrefServiceSyncable* prefs);
+  static void RegisterUserPrefs(PrefService* prefs,
+                                PrefRegistrySyncable* registry);
 
   // Checks if sync is enabled for the profile that owns |io_data|. This must
   // be invoked on the IO thread, and can be used to check if sync is enabled
   // on that thread.
   static bool IsSyncAccessibleOnIOThread(ProfileIOData* io_data);
 
   void AddSyncPrefObserver(SyncPrefObserver* sync_pref_observer);
   void RemoveSyncPrefObserver(SyncPrefObserver* sync_pref_observer);
 
   // Clears important sync preferences.
@@ skipping 57 matching lines @@
 
   // For testing.
 
   void SetManagedForTest(bool is_managed);
   syncer::ModelTypeSet GetAcknowledgeSyncedTypesForTest() const;
 
  private:
   void RegisterPrefGroups();
 
   static void RegisterDataTypePreferredPref(
-      PrefServiceSyncable* prefs, syncer::ModelType type, bool is_preferred);
+      PrefRegistrySyncable* prefs, syncer::ModelType type, bool is_preferred);
   bool GetDataTypePreferred(syncer::ModelType type) const;
   void SetDataTypePreferred(syncer::ModelType type, bool is_preferred);
 
   // Returns a ModelTypeSet based on |types| expanded to include pref groups
   // (see |pref_groups_|), but as a subset of |registered_types|.
   syncer::ModelTypeSet ResolvePrefGroups(
       syncer::ModelTypeSet registered_types,
       syncer::ModelTypeSet types) const;
 
   void OnSyncManagedPrefChanged();
 
   // May be NULL.
-  PrefServiceSyncable* const pref_service_;
+  PrefService* const pref_service_;
 
   ObserverList<SyncPrefObserver> sync_pref_observers_;
 
   // The preference that controls whether sync is under control by
   // configuration management.
   BooleanPrefMember pref_sync_managed_;
 
   // Groups of prefs that always have the same value as a "master" pref.
   // For example, the APPS group has {APP_NOTIFICATIONS, APP_SETTINGS}
   // (as well as APPS, but that is implied), so
   //   pref_groups_[syncer::APPS] =       { syncer::APP_NOTIFICATIONS,
   //                                          syncer::APP_SETTINGS }
   //   pref_groups_[syncer::EXTENSIONS] = { syncer::EXTENSION_SETTINGS }
   // etc.
   typedef std::map<syncer::ModelType, syncer::ModelTypeSet> PrefGroupsMap;
   PrefGroupsMap pref_groups_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPrefs);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_SYNC_PREFS_H_