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(

[raymes, 2016/06/29 03:50:01]

Did you look into whether we should use PrefServiceSyncableObserver instead (you
had mentioned this)? What were your thoughts?

[lshang, 2016/06/30 05:03:36]

PrefServiceSyncableObserver will get called in MergeDataAndStartSyncing() and
StopSyncing(), and StopSyncing() will be called in a list of cases:

- User signed out
- Data type disabled by user through settings
- User enabled passphrase encryption on remote device, but hasn't entered it on
local device yet
- Datatype encountered error
- Browser process shutdown

I also added some log to test this, and it didn't output as I expect (maybe for
some reason, I didn't dig too much). I think it doesn't deserve so much extra
concern or handling of cases to reuse PrefServiceSyncableObserver, compared to
just add a new list of callbacks to pref_model_associator and these callbacks
only get called in MergeDataAndStartSyncing().

+    const base::Closure& callback) {
+  callback_list_.push_back(callback);

[raymes, 2016/06/29 03:50:01]

We should make sure that we only add this if we expect MergeDataAndStartSyncing
to be called in the future. I think we can use models_associated_ here? 

if (!models_associated_)
  callback_list_.push_back(callback);
else
  callback.Run();

[lshang, 2016/06/30 05:03:36]

Done.

+}
+
 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();
+
   // Push updates to sync.
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 
   models_associated_ = true;
   pref_service_->OnIsSyncingChanged();
   return merge_result;
 }
@@ skipping 311 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