Add callback list to PrefModelAssociator after sync data is loaded

components/syncable_prefs/pref_model_associator.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 "components/syncable_prefs/pref_model_associator.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
@@ skipping 139 matching lines @@
                            sync_data));
     synced_preferences_.insert(pref_name);
   }
 
   // Else this pref does not have a sync value but also does not have a user
   // controlled value (either it's a default value or it's policy controlled,
   // either way it's not interesting). We can ignore it. Once it gets changed,
   // we'll send the new user controlled value to the syncer.
 }
 
+void PrefModelAssociator::RegisterMergeDataFinishedCallback(
+    const base::Closure& callback) {
+  if (!models_associated_)
+    callback_list_.push_back(callback);
+  else
+    callback.Run();
+}
+
 syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
     std::unique_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK_EQ(type_, type);
   DCHECK(CalledOnValidThread());
   DCHECK(pref_service_);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
@@ skipping 30 matching lines @@
   }
 
   // Go through and build sync data for any remaining preferences.
   for (std::set<std::string>::iterator pref_name_iter =
           remaining_preferences.begin();
        pref_name_iter != remaining_preferences.end();
        ++pref_name_iter) {
     InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
 
+  for (const auto& callback : callback_list_)
+    callback.Run();
+  callback_list_.clear();

[pavely, 2016/07/06 22:11:56]

I think it is possible that MergeDataAndStartSyncing is called multiple times
for a given object. Scenario would be:
- Sign-in, enable syncing everything (First time MDaSS is called)
- Disable syncing settings (StopSyncing is called)
- Enable syncing settings (Second time MDaSS is called)

[lshang, 2016/07/07 08:26:05]

I think in this case even though the migration code will be called twice, user's
settings will not change again on the second time, because all the domain scoped
content settings have already been migrated to origin scoped styles and it will
output the same result no matter how many times it be called later on. 

We will also register a pref to control this in the following CL, to make sure
that callback in sync only gets called once.

+
   // Push updates to sync.
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 

[pavely, 2016/07/06 22:11:55]

If you want to call a callback only for successful merge you need to move code
here.

[lshang, 2016/07/07 08:26:05]

Done.

   models_associated_ = true;
   pref_service_->OnIsSyncingChanged();
   return merge_result;
 }
 
 void PrefModelAssociator::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(type_, type);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
@@ skipping 305 matching lines @@
   SyncedPrefObserverMap::const_iterator observer_iter =
       synced_pref_observers_.find(path);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second;
   FOR_EACH_OBSERVER(SyncedPrefObserver, *observers,
                     OnSyncedPrefChanged(path, from_sync));
 }
 
 }  // namespace syncable_prefs