Add migration code to change existing domain scoped content settings to be origin scoped

components/syncable_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 COMPONENTS_SYNCABLE_PREFS_PREF_MODEL_ASSOCIATOR_H_
 #define COMPONENTS_SYNCABLE_PREFS_PREF_MODEL_ASSOCIATOR_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 102 matching lines @@
   void RemoveSyncedPrefObserver(const std::string& name,
                                 SyncedPrefObserver* observer);
 
   // Returns the PrefModelAssociatorClient for this object.
   const PrefModelAssociatorClient* client() const { return client_; }
 
   // Set the PrefModelAssociatorClient to use for that object during tests.
   void SetPrefModelAssociatorClientForTesting(
       const PrefModelAssociatorClient* client);
 
+  static void SetMergeDataFinishedCallback(const base::Closure& callback);

[raymes, 2016/06/16 03:23:51]

I don't think we will want these to be static. Instead I think we will want to
get access to the PrefModelAssociator and add a listener.

We can get access to the PrefServiceSyncable from
syncable_prefs::PrefServiceSyncable* PrefServiceSyncableFromProfile() and
passing in the profile and then we could pass the callback down.

We should check with Pavel about all this because I'm just guessing :)

Usually it's good to write functions like this in a general way such that others
can reuse them. That usually means tracking a vector of callbacks in this class.
One way would be to have a function like this:

void AddMergeDataFinishedCallback(... callback) {
  if (merge_finished_) {
    callback.Run();
  else
    merge_finished_callbacks_.push_back(callback);
}

and then in the function where the merge finishes:

...
for (Callback callback : merge_finished_callbacks_)
  callback.Run();
merge_finished_callbacks_.clear();


Again we should probably run that by Pavel for his thoughts.

+  static void ResetMergeDataFinishedCallback();
+
  protected:
   friend class PrefServiceSyncableTest;
 
   typedef std::map<std::string, syncer::SyncData> SyncDataMap;
 
   // Create an association for a given preference. If |sync_pref| is valid,
   // signifying that sync has data for this preference, we reconcile their data
   // 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.
@@ skipping 53 matching lines @@
   // 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_;
   const PrefModelAssociatorClient* client_;  // Weak.
 
+  static base::Closure migrate_call_back_;
+
   DISALLOW_COPY_AND_ASSIGN(PrefModelAssociator);
 };
 
 }  // namespace syncable_prefs
 
 #endif  // COMPONENTS_SYNCABLE_PREFS_PREF_MODEL_ASSOCIATOR_H_