[Sync] Cleanup of device_info_service_unittest.cc

components/sync/device_info/device_info_service_unittest.cc

 // Copyright 2015 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/sync/device_info/device_info_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 29 matching lines @@
 using WriteBatch = ModelTypeStore::WriteBatch;
 
 namespace {
 
 std::unique_ptr<DeviceInfo> CreateDeviceInfo() {
   return base::MakeUnique<DeviceInfo>(
       "guid_1", "client_1", "Chromium 10k", "Chrome 10k",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id");
 }
 
-void AssertResultIsSuccess(Result result) {
-  ASSERT_EQ(Result::SUCCESS, result);
+void VerifyResultIsSuccess(Result result) {
+  EXPECT_EQ(Result::SUCCESS, result);
 }
 
-void AssertEqual(const DeviceInfoSpecifics& s1, const DeviceInfoSpecifics& s2) {
-  ASSERT_EQ(s1.cache_guid(), s2.cache_guid());
-  ASSERT_EQ(s1.client_name(), s2.client_name());
-  ASSERT_EQ(s1.device_type(), s2.device_type());
-  ASSERT_EQ(s1.sync_user_agent(), s2.sync_user_agent());
-  ASSERT_EQ(s1.chrome_version(), s2.chrome_version());
-  ASSERT_EQ(s1.signin_scoped_device_id(), s2.signin_scoped_device_id());
+void VerifyEqual(const DeviceInfoSpecifics& s1, const DeviceInfoSpecifics& s2) {
+  EXPECT_EQ(s1.cache_guid(), s2.cache_guid());
+  EXPECT_EQ(s1.client_name(), s2.client_name());
+  EXPECT_EQ(s1.device_type(), s2.device_type());
+  EXPECT_EQ(s1.sync_user_agent(), s2.sync_user_agent());
+  EXPECT_EQ(s1.chrome_version(), s2.chrome_version());
+  EXPECT_EQ(s1.signin_scoped_device_id(), s2.signin_scoped_device_id());
 }
 
-void AssertEqual(const DeviceInfoSpecifics& specifics,
+void VerifyEqual(const DeviceInfoSpecifics& specifics,
                  const DeviceInfo& model) {
-  ASSERT_EQ(specifics.cache_guid(), model.guid());
-  ASSERT_EQ(specifics.client_name(), model.client_name());
-  ASSERT_EQ(specifics.device_type(), model.device_type());
-  ASSERT_EQ(specifics.sync_user_agent(), model.sync_user_agent());
-  ASSERT_EQ(specifics.chrome_version(), model.chrome_version());
-  ASSERT_EQ(specifics.signin_scoped_device_id(),
+  EXPECT_EQ(specifics.cache_guid(), model.guid());
+  EXPECT_EQ(specifics.client_name(), model.client_name());
+  EXPECT_EQ(specifics.device_type(), model.device_type());
+  EXPECT_EQ(specifics.sync_user_agent(), model.sync_user_agent());
+  EXPECT_EQ(specifics.chrome_version(), model.chrome_version());
+  EXPECT_EQ(specifics.signin_scoped_device_id(),
             model.signin_scoped_device_id());
 }
 
-void AssertExpectedFromDataBatch(
-    std::map<std::string, DeviceInfoSpecifics> expected,
-    SyncError error,
-    std::unique_ptr<DataBatch> batch) {
-  ASSERT_FALSE(error.IsSet());
+void VerifyDataBatch(std::map<std::string, DeviceInfoSpecifics> expected,
+                     SyncError error,
+                     std::unique_ptr<DataBatch> batch) {
+  EXPECT_FALSE(error.IsSet());
   while (batch->HasNext()) {
     const KeyAndData& pair = batch->Next();
-    std::map<std::string, DeviceInfoSpecifics>::iterator iter =
-        expected.find(pair.first);
+    auto iter = expected.find(pair.first);
     ASSERT_NE(iter, expected.end());
-    AssertEqual(iter->second, pair.second->specifics.device_info());
+    VerifyEqual(iter->second, pair.second->specifics.device_info());
     // Removing allows us to verify we don't see the same item multiple times,
     // and that we saw everything we expected.
     expected.erase(iter);
   }
-  ASSERT_TRUE(expected.empty());
+  EXPECT_TRUE(expected.empty());
 }
 
 // Creates an EntityData/EntityDataPtr around a copy of the given specifics.
 EntityDataPtr SpecificsToEntity(const DeviceInfoSpecifics& specifics) {
   EntityData data;
   // These tests do not care about the tag hash, but EntityData and friends
   // cannot differentiate between the default EntityData object if the hash
   // is unset, which causes pass/copy operations to no-op and things start to
   // break, so we throw in a junk value and forget about it.
   data.client_tag_hash = "junk";
   *data.specifics.mutable_device_info() = specifics;
   return data.PassToPtr();
 }
 
 std::string CacheGuidToTag(const std::string& guid) {
   return "DeviceInfo_" + guid;
 }
 
 // Helper method to reduce duplicated code between tests. Wraps the given
-// specifics object in an EntityData and EntityChange of type ACTION_ADD, and
-// pushes them onto the given change list. The corresponding guid of the data
-// is returned, which happens to be the storage key.
-std::string PushBackEntityChangeAdd(const DeviceInfoSpecifics& specifics,
-                                    EntityChangeList* changes) {
-  EntityDataPtr ptr = SpecificsToEntity(specifics);
-  changes->push_back(EntityChange::CreateAdd(specifics.cache_guid(), ptr));
-  return specifics.cache_guid();
+// specifics objects in an EntityData and EntityChange of type ACTION_ADD, and
+// returns an EntityChangeList containing them all. Order is maintained.
+EntityChangeList EntityAddList(
+    std::vector<DeviceInfoSpecifics> specifics_list) {
+  EntityChangeList changes;
+  for (const auto& specifics : specifics_list) {
+    changes.push_back(EntityChange::CreateAdd(specifics.cache_guid(),
+                                              SpecificsToEntity(specifics)));
+  }
+  return changes;
 }
 
 // Instead of actually processing anything, simply accumulates all instructions
 // in members that can then be accessed. TODO(skym): If this ends up being
 // useful for other model type unittests it should be moved out to a shared
 // location.
 class RecordingModelTypeChangeProcessor : public FakeModelTypeChangeProcessor {
  public:
   RecordingModelTypeChangeProcessor() {}
   ~RecordingModelTypeChangeProcessor() override {}
@@ skipping 180 matching lines @@
   // that is slightly different from eachother.
   int generated_count_ = 0;
 };
 
 namespace {
 
 TEST_F(DeviceInfoServiceTest, EmptyDataReconciliation) {
   InitializeAndPump();
   DeviceInfoList devices = service()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
-  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
+  EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 TEST_F(DeviceInfoServiceTest, EmptyDataReconciliationSlowLoad) {
   InitializeService();
-  ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
+  EXPECT_EQ(0u, service()->GetAllDeviceInfo().size());
   base::RunLoop().RunUntilIdle();
   DeviceInfoList devices = service()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
-  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
+  EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 TEST_F(DeviceInfoServiceTest, LocalProviderSubscription) {
   set_local_device(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
 
-  ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
+  EXPECT_EQ(0u, service()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateDeviceInfo());
   base::RunLoop().RunUntilIdle();
 
   DeviceInfoList devices = service()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
-  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
+  EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 // Metadata shouldn't be loaded before the provider is initialized.
 TEST_F(DeviceInfoServiceTest, LocalProviderInitRace) {
   set_local_device(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
   EXPECT_FALSE(processor()->metadata());
 
-  ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
+  EXPECT_EQ(0u, service()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateDeviceInfo());
   base::RunLoop().RunUntilIdle();
 
   DeviceInfoList devices = service()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
-  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
+  EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 
   EXPECT_TRUE(processor()->metadata());
 }
 
 TEST_F(DeviceInfoServiceTest, GetClientTagNormal) {
   InitializeService();
   const std::string guid = "abc";
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info()->set_cache_guid(guid);
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(guid), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, GetClientTagEmpty) {
   InitializeService();
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info();
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(""), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   ASSERT_EQ(2u, service()->GetAllDeviceInfo().size());
-  AssertEqual(specifics,
+  VerifyEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
   InitializeAndPump();
   DeviceInfoList devices = service()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
-  ASSERT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
+  EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
   EXPECT_EQ(1u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalDataAndMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   ASSERT_EQ(2u, service()->GetAllDeviceInfo().size());
-  AssertEqual(specifics,
+  VerifyEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
-  ASSERT_TRUE(processor()->metadata());
-  ASSERT_EQ(state.encryption_key_name(),
+  EXPECT_TRUE(processor()->metadata());
+  EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, GetData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1 = GenerateTestSpecifics();
   DeviceInfoSpecifics specifics2 = GenerateTestSpecifics();
   DeviceInfoSpecifics specifics3 = GenerateTestSpecifics();
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
                      specifics2.SerializeAsString());
   store()->WriteData(batch.get(), specifics3.cache_guid(),
                      specifics3.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
-  std::map<std::string, DeviceInfoSpecifics> expected;
-  expected[specifics1.cache_guid()] = specifics1;
-  expected[specifics3.cache_guid()] = specifics3;
-  StorageKeyList storage_keys;
-  storage_keys.push_back(specifics1.cache_guid());
-  storage_keys.push_back(specifics3.cache_guid());
-  service()->GetData(storage_keys,
-                     base::Bind(&AssertExpectedFromDataBatch, expected));
+  std::map<std::string, DeviceInfoSpecifics> expected{
+      {specifics1.cache_guid(), specifics1},
+      {specifics3.cache_guid(), specifics3}};
+  service()->GetData({specifics1.cache_guid(), specifics3.cache_guid()},
+                     base::Bind(&VerifyDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, GetDataMissing) {
   InitializeAndPump();
-  std::map<std::string, DeviceInfoSpecifics> expected;
-  StorageKeyList storage_keys;
-  storage_keys.push_back("does_not_exist");
-  service()->GetData(storage_keys,
-                     base::Bind(&AssertExpectedFromDataBatch, expected));
+  service()->GetData({"does_not_exist"},
+                     base::Bind(&VerifyDataBatch,
+                                std::map<std::string, DeviceInfoSpecifics>()));
 }
 
 TEST_F(DeviceInfoServiceTest, GetAllData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1 = GenerateTestSpecifics();
   DeviceInfoSpecifics specifics2 = GenerateTestSpecifics();
   const std::string& guid1 = specifics1.cache_guid();
   const std::string& guid2 = specifics2.cache_guid();
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
                      specifics2.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
-  std::map<std::string, DeviceInfoSpecifics> expected;
-  expected[guid1] = specifics1;
-  expected[guid2] = specifics2;
-  StorageKeyList storage_keys;
-  storage_keys.push_back(guid1);
-  storage_keys.push_back(guid2);
-  service()->GetData(storage_keys,
-                     base::Bind(&AssertExpectedFromDataBatch, expected));
+  std::map<std::string, DeviceInfoSpecifics> expected{{guid1, specifics1},
+                                                      {guid2, specifics2}};
+  service()->GetData({guid1, guid2}, base::Bind(&VerifyDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesEmpty) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
   const SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), EntityChangeList());
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesInMemory) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
-  EntityChangeList add_changes;
-  PushBackEntityChangeAdd(specifics, &add_changes);
-  SyncError error = service()->ApplySyncChanges(
-      service()->CreateMetadataChangeList(), add_changes);
+  const SyncError error_on_add = service()->ApplySyncChanges(
+      service()->CreateMetadataChangeList(), EntityAddList({specifics}));
 
-  EXPECT_FALSE(error.IsSet());
+  EXPECT_FALSE(error_on_add.IsSet());
   std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
-  AssertEqual(specifics, *info.get());
+  VerifyEqual(specifics, *info.get());
   EXPECT_EQ(2, change_count());
 
-  EntityChangeList delete_changes;
-  delete_changes.push_back(EntityChange::CreateDelete(specifics.cache_guid()));
-  error = service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
-                                      delete_changes);
+  const SyncError error_on_delete = service()->ApplySyncChanges(
+      service()->CreateMetadataChangeList(),
+      {EntityChange::CreateDelete(specifics.cache_guid())});
 
-  EXPECT_FALSE(error.IsSet());
+  EXPECT_FALSE(error_on_delete.IsSet());
   EXPECT_FALSE(service()->GetDeviceInfo(specifics.cache_guid()));
   EXPECT_EQ(3, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesStore) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
-  EntityChangeList data_changes;
-  PushBackEntityChangeAdd(specifics, &data_changes);
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes =
       service()->CreateMetadataChangeList();
   metadata_changes->UpdateModelTypeState(state);
 
-  const SyncError error =
-      service()->ApplySyncChanges(std::move(metadata_changes), data_changes);
+  const SyncError error = service()->ApplySyncChanges(
+      std::move(metadata_changes), EntityAddList({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   RestartService();
 
   std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
-  AssertEqual(specifics, *info.get());
+  VerifyEqual(specifics, *info.get());
 
   EXPECT_TRUE(processor()->metadata());
   EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesWithLocalGuid) {
   InitializeAndPump();
 
   // The point of this test is to try to apply remote changes that have the same
   // cache guid as the local device. The service should ignore these changes
   // since only it should be performing writes on its data.
   DeviceInfoSpecifics specifics =
       GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
-  EntityChangeList change_list;
-  PushBackEntityChangeAdd(specifics, &change_list);
 
   // Should have a single change from reconciliation.
   EXPECT_TRUE(
       service()->GetDeviceInfo(local_device()->GetLocalDeviceInfo()->guid()));
   EXPECT_EQ(1, change_count());
   // Ensure |last_updated| is about now, plus or minus a little bit.
   Time last_updated(ProtoTimeToTime(processor()
                                         ->put_multimap()
                                         .begin()
                                         ->second->specifics.device_info()
                                         .last_updated_timestamp()));
   EXPECT_LT(Time::Now() - TimeDelta::FromMinutes(1), last_updated);
   EXPECT_GT(Time::Now() + TimeDelta::FromMinutes(1), last_updated);
 
-  EXPECT_FALSE(
-      service()
-          ->ApplySyncChanges(service()->CreateMetadataChangeList(), change_list)
-          .IsSet());
+  const SyncError error_on_add = service()->ApplySyncChanges(
+      service()->CreateMetadataChangeList(), EntityAddList({specifics}));
+  EXPECT_FALSE(error_on_add.IsSet());
   EXPECT_EQ(1, change_count());
 
-  change_list.clear();
-  change_list.push_back(EntityChange::CreateDelete(specifics.cache_guid()));
-  EXPECT_FALSE(
-      service()
-          ->ApplySyncChanges(service()->CreateMetadataChangeList(), change_list)
-          .IsSet());
+  const SyncError error_on_delete = service()->ApplySyncChanges(
+      service()->CreateMetadataChangeList(),
+      {EntityChange::CreateDelete(specifics.cache_guid())});
+  EXPECT_FALSE(error_on_delete.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplyDeleteNonexistent) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
-  EntityChangeList delete_changes;
-  delete_changes.push_back(EntityChange::CreateDelete("guid"));
-  const SyncError error = service()->ApplySyncChanges(
-      service()->CreateMetadataChangeList(), delete_changes);
+  const SyncError error =
+      service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
+                                  {EntityChange::CreateDelete("guid")});
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeEmpty) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), EntityDataMap());
   EXPECT_FALSE(error.IsSet());
@@ skipping 17 matching lines @@
       GenerateTestSpecifics(conflict_guid);
   const DeviceInfoSpecifics unique_remote =
       GenerateTestSpecifics("unique_remote_guid");
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   store()->WriteData(batch.get(), unique_local.cache_guid(),
                      unique_local.SerializeAsString());
   store()->WriteData(batch.get(), conflict_local.cache_guid(),
                      conflict_local.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   EntityDataMap remote_input;
   remote_input[conflict_remote.cache_guid()] =
       SpecificsToEntity(conflict_remote);
   remote_input[unique_remote.cache_guid()] = SpecificsToEntity(unique_remote);
 
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
   metadata_changes->UpdateModelTypeState(state);
 
   const SyncError error =
       service()->MergeSyncData(std::move(metadata_changes), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   // The remote should beat the local in conflict.
   EXPECT_EQ(4u, service()->GetAllDeviceInfo().size());
-  AssertEqual(unique_local,
+  VerifyEqual(unique_local,
               *service()->GetDeviceInfo(unique_local.cache_guid()).get());
-  AssertEqual(unique_remote,
+  VerifyEqual(unique_remote,
               *service()->GetDeviceInfo(unique_remote.cache_guid()).get());
-  AssertEqual(conflict_remote, *service()->GetDeviceInfo(conflict_guid).get());
+  VerifyEqual(conflict_remote, *service()->GetDeviceInfo(conflict_guid).get());
 
   // Service should have told the processor about the existance of unique_local.
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_EQ(3u, processor()->put_multimap().size());
   EXPECT_EQ(1u, processor()->put_multimap().count(unique_local.cache_guid()));
   const auto& it = processor()->put_multimap().find(unique_local.cache_guid());
   ASSERT_NE(processor()->put_multimap().end(), it);
-  AssertEqual(unique_local, it->second->specifics.device_info());
+  VerifyEqual(unique_local, it->second->specifics.device_info());
 
   RestartService();
-  ASSERT_EQ(state.encryption_key_name(),
+  EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeLocalGuid) {
   const DeviceInfo* local_device_info = local_device()->GetLocalDeviceInfo();
   std::unique_ptr<DeviceInfoSpecifics> specifics =
       CopyToSpecifics(*local_device_info);
   specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
   const std::string guid = local_device_info->guid();
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   store()->WriteData(batch.get(), guid, specifics->SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&AssertResultIsSuccess));
+                            base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   EntityDataMap remote_input;
   remote_input[guid] = SpecificsToEntity(*specifics);
 
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
@@ skipping 12 matching lines @@
   EXPECT_EQ(Time(), GetLastUpdateTime(specifics1));
   EXPECT_EQ(time1, GetLastUpdateTime(specifics2));
 }
 
 TEST_F(DeviceInfoServiceTest, CountActiveDevices) {
   InitializeAndPump();
   EXPECT_EQ(1, service()->CountActiveDevices());
 
   DeviceInfoSpecifics specifics =
       GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
-  EntityChangeList change_list;
-  PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
-                              change_list);
+                              EntityAddList({specifics}));
   EXPECT_EQ(1, service()->CountActiveDevices());
 
-  change_list.clear();
   specifics.set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
-  PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
-                              change_list);
+                              EntityAddList({specifics}));
   EXPECT_EQ(1, service()->CountActiveDevices());
 
-  change_list.clear();
   specifics.set_cache_guid("non-local");
-  PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
-                              change_list);
+                              EntityAddList({specifics}));
   EXPECT_EQ(2, service()->CountActiveDevices());
 }
 
 TEST_F(DeviceInfoServiceTest, MultipleOnProviderInitialized) {
   set_local_device(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
   EXPECT_EQ(nullptr, processor()->metadata());
 
   // Verify the processor was given metadata.
   local_device()->Initialize(CreateDeviceInfo());
@@ skipping 24 matching lines @@
   EXPECT_EQ(2, change_count());
   EXPECT_EQ(2u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoServiceTest, DisableSync) {
   InitializeAndPump();
   EXPECT_EQ(1u, service()->GetAllDeviceInfo().size());
   EXPECT_EQ(1, change_count());
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
-  EntityChangeList add_changes;
-  PushBackEntityChangeAdd(specifics, &add_changes);
   const SyncError error = service()->ApplySyncChanges(
-      service()->CreateMetadataChangeList(), add_changes);
+      service()->CreateMetadataChangeList(), EntityAddList({specifics}));
 
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2u, service()->GetAllDeviceInfo().size());
   EXPECT_EQ(2, change_count());
 
   // Should clear out all local data and notify observers.
   service()->DisableSync();
   EXPECT_EQ(0u, service()->GetAllDeviceInfo().size());
   EXPECT_EQ(3, change_count());
 
   // Reloading from storage shouldn't contain remote data.
   RestartService();
   EXPECT_EQ(1u, service()->GetAllDeviceInfo().size());
   EXPECT_EQ(4, change_count());
 }
 
 }  // namespace
 
 }  // namespace syncer