Add callback list to PrefModelAssociator after sync data is loaded

components/syncable_prefs/pref_service_syncable_unittest.cc

 // Copyright 2014 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_service_syncable.h"
 
 #include <stdint.h>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 103 matching lines @@
         kListPrefName,
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
     prefs_.registry()->RegisterStringPref(
         kDefaultCharsetPrefName,
         kDefaultCharsetValue,
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 
     pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>(
         prefs_.GetSyncableService(syncer::PREFERENCES));
     ASSERT_TRUE(pref_sync_service_);
     next_pref_remote_sync_node_id_ = 0;

[Bernhard Bauer, 2016/07/13 08:31:52]

This is not necessary, BTW (each test gets a new fixture insteance).

[lshang, 2016/07/14 01:29:03]

Done.

+    callback_test_num = 0;

[Bernhard Bauer, 2016/07/13 08:31:52]

I would initialize this in the constructor.

[lshang, 2016/07/14 01:29:04]

Done. Also added an underscore at the end of this variable's name since it's a
member of the class.

Oh this is deleted later since I moved it to the anonymous namespace.

   }
 
   syncer::SyncChange MakeRemoteChange(int64_t id,
                                       const std::string& name,
                                       const base::Value& value,
                                       SyncChange::SyncChangeType type) {
     std::string serialized;
     JSONStringValueSerializer json(&serialized);
     if (!json.Serialize(value))
       return syncer::SyncChange();
@@ skipping 62 matching lines @@
   }
 
   bool IsSynced(const std::string& pref_name) {
     return pref_sync_service_->registered_preferences().count(pref_name) > 0;
   }
 
   bool HasSyncData(const std::string& pref_name) {
     return pref_sync_service_->IsPrefSynced(pref_name);
   }
 
+  void CallbackFunc() { callback_test_num += 1; }

[Bernhard Bauer, 2016/07/13 08:31:52]

Nit: you could use ++.

[lshang, 2016/07/14 01:29:03]

Done.

+
   PrefService* GetPrefs() { return &prefs_; }
   TestingPrefServiceSyncable* GetTestingPrefService() { return &prefs_; }
 
  protected:
   TestPrefModelAssociatorClient client_;
   TestingPrefServiceSyncable prefs_;
 
   PrefModelAssociator* pref_sync_service_;
   TestSyncProcessorStub* test_processor_;
 
   // TODO(tim): Remove this by fixing AttachmentServiceProxyForTest.
   base::MessageLoop loop_;
 
   int next_pref_remote_sync_node_id_;
+
+  int callback_test_num;

[Bernhard Bauer, 2016/07/13 08:31:52]

Nit: |num_callbacks|?

Alternatively, you could use a static function (in an anonymous namespace) that
takes an int* and increments it, and then bind it with the address of a variable
on the stack. That way, you don't need to have any state in the fixture.

[lshang, 2016/07/14 01:29:04]

Done. The alternative is really cool!

 };
 
 TEST_F(PrefServiceSyncableTest, CreatePrefSyncData) {
   prefs_.SetString(kStringPrefName, kExampleUrl0);
 
   const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName);
   syncer::SyncData sync_data;
   EXPECT_TRUE(pref_sync_service_->CreatePrefSyncData(pref->name(),
       *pref->GetValue(), &sync_data));
   EXPECT_EQ(std::string(kStringPrefName),
@@ skipping 317 matching lines @@
   InitWithNoSyncData();
 
   std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
   syncer::SyncChangeList list;
   list.push_back(MakeRemoteChange(
       1, kStringPrefName, *null_value, SyncChange::ACTION_DELETE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(pref->IsDefaultValue());
 }
 
+TEST_F(PrefServiceSyncableTest, RegisterMergeDataFinishedCallback) {
+  EXPECT_EQ(callback_test_num, 0);

[Bernhard Bauer, 2016/07/13 08:31:52]

The expected value goes first, for nicer error messages in case of failure.

[lshang, 2016/07/14 01:29:03]

Done.

+  prefs_.RegisterMergeDataFinishedCallback(base::Bind(
+      &PrefServiceSyncableTest::CallbackFunc, base::Unretained(this)));
+  EXPECT_EQ(callback_test_num, 0);
+  InitWithNoSyncData();
+  EXPECT_EQ(callback_test_num, 1);
+}
+
 }  // namespace
 
 }  // namespace syncable_prefs