[Sync] Minor refactoring of DeviceInfoSyncBridgeTest.

components/sync/device_info/device_info_sync_bridge_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_sync_bridge.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 50 matching lines @@
   specifics.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
   specifics.set_sync_user_agent(
       base::StringPrintf(kSyncUserAgentFormat, suffix));
   specifics.set_chrome_version(
       base::StringPrintf(kChromeVersionFormat, suffix));
   specifics.set_signin_scoped_device_id(
       base::StringPrintf(kSigninScopedDeviceIdFormat, suffix));
   return specifics;
 }
 
+DeviceInfoSpecifics CreateSpecifics(int suffix, Time last_updated_timestamp) {
+  DeviceInfoSpecifics specifics = CreateSpecifics(suffix);
+  specifics.set_last_updated_timestamp(TimeToProtoTime(last_updated_timestamp));
+  return specifics;
+}
+
 std::unique_ptr<DeviceInfo> CreateModel(int suffix) {
   return base::MakeUnique<DeviceInfo>(
       base::StringPrintf(kGuidFormat, suffix),
       base::StringPrintf(kClientNameFormat, suffix),
       base::StringPrintf(kChromeVersionFormat, suffix),
       base::StringPrintf(kSyncUserAgentFormat, suffix), kDeviceType,
       base::StringPrintf(kSigninScopedDeviceIdFormat, suffix));
 }
 
+ModelTypeState StateWithEncryption(const std::string& encryption_key_name) {
+  ModelTypeState state;
+  state.set_encryption_key_name(encryption_key_name);
+  return state;
+}
+
 void VerifyResultIsSuccess(Result result) {
   EXPECT_EQ(Result::SUCCESS, result);
 }
 
 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());
@@ skipping 40 matching lines @@
 }
 
 std::string CacheGuidToTag(const std::string& guid) {
   return "DeviceInfo_" + guid;
 }
 
 // Helper method to reduce duplicated code between tests. Wraps the given
 // 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) {
+    const 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;
 }
 
+// Similar helper to EntityAddList(...), only wraps in a EntityDataMap for a
+// merge call. Order is irrelevant, since the map sorts by key. Should not
+// contain multiple specifics with the same guid.
+EntityDataMap InlineEntityDataMap(
+    const std::vector<DeviceInfoSpecifics>& specifics_list) {
+  EntityDataMap map;
+  for (const auto& specifics : specifics_list) {
+    EXPECT_EQ(map.end(), map.find(specifics.cache_guid()));
+    map[specifics.cache_guid()] = SpecificsToEntity(specifics);
+  }
+  return map;
+}
+
 // 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 {}
 
   void Put(const std::string& storage_key,
@@ skipping 114 matching lines @@
     bridge_.reset();
   }
 
   void RestartBridge() {
     PumpAndShutdown();
     InitializeAndPump();
   }
 
   void ForcePulse() { bridge()->SendLocalData(); }
 
+  void WriteToStore(const std::vector<DeviceInfoSpecifics>& specifics_list,
+                    std::unique_ptr<WriteBatch> batch) {
+    // The bridge only reads from the store during initialization, so if the
+    // |bridge_| has already been initialized, then it may not have an effect.
+    EXPECT_FALSE(bridge_);
+    for (auto& specifics : specifics_list) {
+      batch->WriteData(specifics.cache_guid(), specifics.SerializeAsString());
+    }
+    store()->CommitWriteBatch(std::move(batch),
+                              base::Bind(&VerifyResultIsSuccess));
+  }
+
+  void WriteToStore(const std::vector<DeviceInfoSpecifics>& specifics_list,
+                    ModelTypeState state) {
+    std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
+    batch->GetMetadataChangeList()->UpdateModelTypeState(state);
+    WriteToStore(specifics_list, std::move(batch));
+  }
+
+  void WriteToStore(const std::vector<DeviceInfoSpecifics>& specifics_list) {
+    WriteToStore(specifics_list, store()->CreateWriteBatch());
+  }
+
  private:
   int change_count_ = 0;
 
   // In memory model type store needs a MessageLoop.
   base::MessageLoop message_loop_;
 
   // Holds the store while the bridge is not initialized.
   std::unique_ptr<ModelTypeStore> store_;
 
   // Provides information about the local device. Is initialized in each case's
   // constructor with a model object created from |kDefaultLocalSuffix|.
   std::unique_ptr<LocalDeviceInfoProviderMock> provider_;
 
   // Not initialized immediately (upon test's constructor). This allows each
   // test case to modify the dependencies the bridge will be constructed with.
   std::unique_ptr<DeviceInfoSyncBridge> bridge_;
 
   // A non-owning pointer to the processor given to the bridge. Will be null
   // before being given to the bridge, to make ownership easier.
   RecordingModelTypeChangeProcessor* processor_ = nullptr;
 };
 
 namespace {
 
 TEST_F(DeviceInfoSyncBridgeTest, EmptyDataReconciliation) {
   InitializeAndPump();
-  DeviceInfoList devices = bridge()->GetAllDeviceInfo();
+  const DeviceInfoList devices = bridge()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, EmptyDataReconciliationSlowLoad) {
   InitializeBridge();
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
   base::RunLoop().RunUntilIdle();
-  DeviceInfoList devices = bridge()->GetAllDeviceInfo();
+  const DeviceInfoList devices = bridge()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, LocalProviderSubscription) {
   set_provider(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
 
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateModel(1));
   base::RunLoop().RunUntilIdle();
 
-  DeviceInfoList devices = bridge()->GetAllDeviceInfo();
+  const DeviceInfoList devices = bridge()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 }
 
 // Metadata shouldn't be loaded before the provider is initialized.
 TEST_F(DeviceInfoSyncBridgeTest, LocalProviderInitRace) {
   set_provider(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
   EXPECT_FALSE(processor()->metadata());
 
@@ skipping 21 matching lines @@
 TEST_F(DeviceInfoSyncBridgeTest, GetClientTagEmpty) {
   InitializeBridge();
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info();
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(""), bridge()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalData) {
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  batch->WriteData(specifics.cache_guid(), specifics.SerializeAsString());
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
-
+  const DeviceInfoSpecifics specifics = CreateSpecifics(1);
+  WriteToStore({specifics});
   InitializeAndPump();
 
   ASSERT_EQ(2u, bridge()->GetAllDeviceInfo().size());
   VerifyEqual(specifics,
               *bridge()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalMetadata) {
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  ModelTypeState state;
-  state.set_encryption_key_name("ekn");
-  batch->GetMetadataChangeList()->UpdateModelTypeState(state);
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
+  WriteToStore(std::vector<DeviceInfoSpecifics>(), StateWithEncryption("ekn"));
   InitializeAndPump();
-  DeviceInfoList devices = bridge()->GetAllDeviceInfo();
+
+  const DeviceInfoList devices = bridge()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
   EXPECT_EQ(1u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalDataAndMetadata) {
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  batch->WriteData(specifics.cache_guid(), specifics.SerializeAsString());
-  ModelTypeState state;
-  state.set_encryption_key_name("ekn");
-  batch->GetMetadataChangeList()->UpdateModelTypeState(state);
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
-
+  const DeviceInfoSpecifics specifics = CreateSpecifics(1);
+  ModelTypeState state = StateWithEncryption("ekn");
+  WriteToStore({specifics}, state);
   InitializeAndPump();
 
   ASSERT_EQ(2u, bridge()->GetAllDeviceInfo().size());
   VerifyEqual(specifics,
               *bridge()->GetDeviceInfo(specifics.cache_guid()).get());
   EXPECT_TRUE(processor()->metadata());
   EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetData) {
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
-  DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
-  DeviceInfoSpecifics specifics3 = CreateSpecifics(3);
-  batch->WriteData(specifics1.cache_guid(), specifics1.SerializeAsString());
-  batch->WriteData(specifics2.cache_guid(), specifics2.SerializeAsString());
-  batch->WriteData(specifics3.cache_guid(), specifics3.SerializeAsString());
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
-
+  const DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
+  const DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
+  const DeviceInfoSpecifics specifics3 = CreateSpecifics(3);
+  WriteToStore({specifics1, specifics2, specifics3});
   InitializeAndPump();
 
-  std::map<std::string, DeviceInfoSpecifics> expected{
+  const std::map<std::string, DeviceInfoSpecifics> expected{
       {specifics1.cache_guid(), specifics1},
       {specifics3.cache_guid(), specifics3}};
   bridge()->GetData({specifics1.cache_guid(), specifics3.cache_guid()},
                     base::Bind(&VerifyDataBatch, expected));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetDataMissing) {
   InitializeAndPump();
   bridge()->GetData({"does_not_exist"},
                     base::Bind(&VerifyDataBatch,
                                std::map<std::string, DeviceInfoSpecifics>()));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetAllData) {
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
-  DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
-  const std::string& guid1 = specifics1.cache_guid();
-  const std::string& guid2 = specifics2.cache_guid();
-  batch->WriteData(specifics1.cache_guid(), specifics1.SerializeAsString());
-  batch->WriteData(specifics2.cache_guid(), specifics2.SerializeAsString());
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
-
+  const DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
+  const DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
+  WriteToStore({specifics1, specifics2});
   InitializeAndPump();
 
-  std::map<std::string, DeviceInfoSpecifics> expected{{guid1, specifics1},
-                                                      {guid2, specifics2}};
-  bridge()->GetData({guid1, guid2}, base::Bind(&VerifyDataBatch, expected));
+  const std::map<std::string, DeviceInfoSpecifics> expected{
+      {specifics1.cache_guid(), specifics1},
+      {specifics2.cache_guid(), specifics2}};
+  bridge()->GetData({specifics1.cache_guid(), specifics2.cache_guid()},
+                    base::Bind(&VerifyDataBatch, expected));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesEmpty) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
   const SyncError error = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityChangeList());
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesInMemory) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
-  DeviceInfoSpecifics specifics = CreateSpecifics(1);
+  const DeviceInfoSpecifics specifics = CreateSpecifics(1);
   const SyncError error_on_add = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
 
   EXPECT_FALSE(error_on_add.IsSet());
   std::unique_ptr<DeviceInfo> info =
       bridge()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   VerifyEqual(specifics, *info.get());
   EXPECT_EQ(2, change_count());
 
   const SyncError error_on_delete = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(),
       {EntityChange::CreateDelete(specifics.cache_guid())});
 
   EXPECT_FALSE(error_on_delete.IsSet());
   EXPECT_FALSE(bridge()->GetDeviceInfo(specifics.cache_guid()));
   EXPECT_EQ(3, change_count());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesStore) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
-  DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  ModelTypeState state;
-  state.set_encryption_key_name("ekn");
+  const DeviceInfoSpecifics specifics = CreateSpecifics(1);
+  ModelTypeState state = StateWithEncryption("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes =
       bridge()->CreateMetadataChangeList();
   metadata_changes->UpdateModelTypeState(state);
 
   const SyncError error = bridge()->ApplySyncChanges(
       std::move(metadata_changes), EntityAddList({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   RestartBridge();
 
   std::unique_ptr<DeviceInfo> info =
       bridge()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   VerifyEqual(specifics, *info.get());
 
   EXPECT_TRUE(processor()->metadata());
   EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesWithLocalGuid) {
   InitializeAndPump();
 
   // The bridge should ignore these changes using this specifics because its
   // guid will match the local device.
-  DeviceInfoSpecifics specifics = CreateSpecifics(kDefaultLocalSuffix);
+  const DeviceInfoSpecifics specifics = CreateSpecifics(kDefaultLocalSuffix);
 
   // Should have a single change from reconciliation.
   EXPECT_TRUE(
       bridge()->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()));
+  const 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);
 
   const SyncError error_on_add = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
   EXPECT_FALSE(error_on_add.IsSet());
   EXPECT_EQ(1, change_count());
 
   const SyncError error_on_delete = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(),
@@ skipping 31 matching lines @@
 TEST_F(DeviceInfoSyncBridgeTest, MergeWithData) {
   const DeviceInfoSpecifics unique_local = CreateSpecifics(1);
   DeviceInfoSpecifics conflict_local = CreateSpecifics(2);
   DeviceInfoSpecifics conflict_remote = CreateSpecifics(3);
   const DeviceInfoSpecifics unique_remote = CreateSpecifics(4);
 
   const std::string conflict_guid = "conflict_guid";
   conflict_local.set_cache_guid(conflict_guid);
   conflict_remote.set_cache_guid(conflict_guid);
 
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  batch->WriteData(unique_local.cache_guid(), unique_local.SerializeAsString());
-  batch->WriteData(conflict_local.cache_guid(),
-                   conflict_local.SerializeAsString());
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
-
+  WriteToStore({unique_local, conflict_local});
   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");
+  ModelTypeState state = StateWithEncryption("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes =
       bridge()->CreateMetadataChangeList();
   metadata_changes->UpdateModelTypeState(state);
 
-  const SyncError error =
-      bridge()->MergeSyncData(std::move(metadata_changes), remote_input);
+  const SyncError error = bridge()->MergeSyncData(
+      std::move(metadata_changes),
+      InlineEntityDataMap({conflict_remote, unique_remote}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   // The remote should beat the local in conflict.
   EXPECT_EQ(4u, bridge()->GetAllDeviceInfo().size());
   VerifyEqual(unique_local,
               *bridge()->GetDeviceInfo(unique_local.cache_guid()).get());
   VerifyEqual(unique_remote,
               *bridge()->GetDeviceInfo(unique_remote.cache_guid()).get());
   VerifyEqual(conflict_remote, *bridge()->GetDeviceInfo(conflict_guid).get());
 
   // bridge 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);
   VerifyEqual(unique_local, it->second->specifics.device_info());
 
   RestartBridge();
   EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuid) {
-  const DeviceInfo* provider_info = local_device()->GetLocalDeviceInfo();
-  auto specifics = base::MakeUnique<DeviceInfoSpecifics>(CreateSpecifics(0));
-  specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
-  const std::string guid = provider_info->guid();
-
-  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  batch->WriteData(guid, specifics->SerializeAsString());
-  store()->CommitWriteBatch(std::move(batch),
-                            base::Bind(&VerifyResultIsSuccess));
-
+  // If not recent, then reconcile is going to try to send an updated version to
+  // Sync, which makes interpreting change_count() more difficult.
+  const DeviceInfoSpecifics specifics =
+      CreateSpecifics(kDefaultLocalSuffix, Time::Now());
+  WriteToStore({specifics});
   InitializeAndPump();
 
-  EntityDataMap remote_input;
-  remote_input[guid] = SpecificsToEntity(*specifics);
-
   const SyncError error = bridge()->MergeSyncData(
-      bridge()->CreateMetadataChangeList(), remote_input);
+      bridge()->CreateMetadataChangeList(), InlineEntityDataMap({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_TRUE(processor()->put_multimap().empty());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuidBeforeReconcile) {
   InitializeBridge();
-  const DeviceInfoSpecifics specifics = CreateSpecifics(kDefaultLocalSuffix);
 
   // The message loop is never pumped, which means local data/metadata is never
   // loaded, and thus reconcile is never called. The bridge should ignore this
   // EntityData because its cache guid is the same the local device's.
   const SyncError error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(),
-      {{specifics.cache_guid(), SpecificsToEntity(specifics)}});
+      InlineEntityDataMap({CreateSpecifics(kDefaultLocalSuffix)}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, CountActiveDevices) {
   InitializeAndPump();
   EXPECT_EQ(1, bridge()->CountActiveDevices());
 
-  DeviceInfoSpecifics specifics = CreateSpecifics(0);
-  bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
-                             EntityAddList({specifics}));
+  // Regardless of the time, these following two ApplySyncChanges(...) calls
+  // have the same guid as the local device.
+  bridge()->ApplySyncChanges(
+      bridge()->CreateMetadataChangeList(),
+      EntityAddList({CreateSpecifics(kDefaultLocalSuffix)}));
   EXPECT_EQ(1, bridge()->CountActiveDevices());
 
-  specifics.set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
-  bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
-                             EntityAddList({specifics}));
+  bridge()->ApplySyncChanges(
+      bridge()->CreateMetadataChangeList(),
+      EntityAddList({CreateSpecifics(kDefaultLocalSuffix, Time::Now())}));
   EXPECT_EQ(1, bridge()->CountActiveDevices());
 
-  specifics.set_cache_guid("non-local");
+  // A different guid will actually contribute to the count.
   bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
-                             EntityAddList({specifics}));
+                             EntityAddList({CreateSpecifics(1, Time::Now())}));
   EXPECT_EQ(2, bridge()->CountActiveDevices());
 
   // Now set time to long ago in the past, it should not be active anymore.
-  specifics.set_last_updated_timestamp(TimeToProtoTime(Time()));
   bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
-                             EntityAddList({specifics}));
+                             EntityAddList({CreateSpecifics(1)}));
   EXPECT_EQ(1, bridge()->CountActiveDevices());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MultipleOnProviderInitialized) {
   set_provider(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
   EXPECT_EQ(nullptr, processor()->metadata());
 
   // Verify the processor was given metadata.
   local_device()->Initialize(CreateModel(0));
@@ skipping 23 matching lines @@
   ForcePulse();
   EXPECT_EQ(2, change_count());
   EXPECT_EQ(2u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, DisableSync) {
   InitializeAndPump();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(1, change_count());
 
-  DeviceInfoSpecifics specifics = CreateSpecifics(1);
+  const DeviceInfoSpecifics specifics = CreateSpecifics(1);
   const SyncError error = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
 
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(2, change_count());
 
   // Should clear out all local data and notify observers.
   bridge()->DisableSync();
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(3, change_count());
 
   // Reloading from storage shouldn't contain remote data.
   RestartBridge();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(4, change_count());
 }
 
 }  // namespace
 
 }  // namespace syncer