Remove dependency of PrefSyncableService on Profile.

chrome/browser/prefs/pref_model_associator.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_PREFS_PREF_MODEL_ASSOCIATOR_H_
 #define CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/prefs/synced_pref_observer.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/syncable_service.h"
 
+class PrefModelAssociatorClient;
 class PrefRegistrySyncable;
 class PrefServiceSyncable;
 
 namespace sync_pb {
 class PreferenceSpecifics;
 }
 
 namespace base {
 class Value;
 }
 
 // Contains all preference sync related logic.
 // TODO(sync): Merge this into PrefService once we separate the profile
 // PrefService from the local state PrefService.
-class PrefModelAssociator
-    : public syncer::SyncableService,
-      public base::NonThreadSafe {
+class PrefModelAssociator : public syncer::SyncableService,
+                            public base::NonThreadSafe {
  public:
   explicit PrefModelAssociator(syncer::ModelType type);
   ~PrefModelAssociator() override;
 
   // See description above field for details.
   bool models_associated() const { return models_associated_; }
 
   // syncer::SyncableService implementation.
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override;
   syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) override;
   syncer::SyncMergeResult MergeDataAndStartSyncing(
       syncer::ModelType type,
       const syncer::SyncDataList& initial_sync_data,
       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
       scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) override;
   void StopSyncing(syncer::ModelType type) override;
 
   // Returns the list of preference names that are registered as syncable, and
   // hence should be monitored for changes.
   std::set<std::string> registered_preferences() const;
 
+  // Sets the PrefModelAssociatorClient that control special treatment of
+  // some preferences during synchronisation. Must be called before starting
+  // the synchronisation.
+  void set_pref_model_associator_client(
+      PrefModelAssociatorClient* pref_model_associator_client) {
+    pref_model_associator_client_ = pref_model_associator_client;
+  }
+
   // Register a preference with the specified name for syncing. We do not care
   // about the type at registration time, but when changes arrive from the
   // syncer, we check if they can be applied and if not drop them.
   // Note: This should only be called at profile startup time (before sync
   // begins).
   virtual void RegisterPref(const char* name);
 
   // Returns true if the specified preference is registered for syncing.
   virtual bool IsPrefRegistered(const char* name);
 
   // Process a local preference change. This can trigger new SyncChanges being
   // sent to the syncer.
   virtual void ProcessPrefChange(const std::string& name);
 
   void SetPrefService(PrefServiceSyncable* pref_service);
 
   // Merges the local_value into the supplied server_value and returns
   // the result (caller takes ownership). If there is a conflict, the server
   // value always takes precedence. Note that only certain preferences will
   // actually be merged, all others will return a copy of the server value. See
   // the method's implementation for details.
   static scoped_ptr<base::Value> MergePreference(
       const std::string& name,
       const base::Value& local_value,
-      const base::Value& server_value);
+      const base::Value& server_value,
+      PrefModelAssociatorClient* pref_model_associator_registry);
 
   // Fills |sync_data| with a sync representation of the preference data
   // provided.
   bool CreatePrefSyncData(const std::string& name,
                           const base::Value& value,
                           syncer::SyncData* sync_data) const;
 
   // Extract preference value from sync specifics.
   base::Value* ReadPreferenceSpecifics(
       const sync_pb::PreferenceSpecifics& specifics);
@@ skipping 20 matching lines @@
   // with ours and append a new UPDATE SyncChange to |sync_changes|. If
   // sync_pref is not set, we append an ADD SyncChange to |sync_changes| with
   // the current preference data.
   // Note: We do not modify the sync data for preferences that are either
   // controlled by policy (are not user modifiable) or have their default value
   // (are not user controlled).
   void InitPrefAndAssociate(const syncer::SyncData& sync_pref,
                             const std::string& pref_name,
                             syncer::SyncChangeList* sync_changes);
 
-  static base::Value* MergeListValues(
-      const base::Value& from_value, const base::Value& to_value);
+  static base::Value* MergeListValues(const base::Value& from_value,
+                                      const base::Value& to_value);
   static base::Value* MergeDictionaryValues(const base::Value& from_value,
                                             const base::Value& to_value);
 
   // Do we have an active association between the preferences and sync models?
   // Set when start syncing, reset in StopSyncing. While this is not set, we
   // ignore any local preference changes (when we start syncing we will look
   // up the most recent values anyways).
   bool models_associated_;
 
   // Whether we're currently processing changes from the syncer. While this is
@@ skipping 32 matching lines @@
   // Map prefs to lists of observers. Observers will receive notification when
   // a pref changes, including the detail of whether or not the change came
   // from sync.
   typedef base::ObserverList<SyncedPrefObserver> SyncedPrefObserverList;
   typedef base::hash_map<std::string, SyncedPrefObserverList*>
       SyncedPrefObserverMap;
 
   void NotifySyncedPrefObservers(const std::string& path, bool from_sync) const;
 
   SyncedPrefObserverMap synced_pref_observers_;
+  PrefModelAssociatorClient* pref_model_associator_client_;

[gab, 2015/09/10 14:15:09]

Should this be a const*?

 
   DISALLOW_COPY_AND_ASSIGN(PrefModelAssociator);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_