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 36 matching lines @@
        ++pref_name_iter) {
     InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
 
   // Push updates to sync.
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 
+  for (const auto& callback : callback_list_)
+    callback.Run();
+  callback_list_.clear();
+
   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