[Sync] DeviceInfoService should format ClientTag in backwards compatible way

components/sync_driver/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_driver/device_info_service.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 95 matching lines @@
   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;
+}
+
 // 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 syncer_v2::FakeModelTypeChangeProcessor {
  public:
   RecordingModelTypeChangeProcessor() {}
   ~RecordingModelTypeChangeProcessor() override {}
 
@@ skipping 230 matching lines @@
       local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
 }
 
 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(guid, service()->GetClientTag(entity_data));
+  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("", service()->GetClientTag(entity_data));
+  EXPECT_EQ(CacheGuidToTag(""), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalData) {
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics(GenerateTestSpecifics());
-  store()->WriteData(batch.get(), "tag", specifics.SerializeAsString());
+  store()->WriteData(batch.get(), specifics.cache_guid(),
+                     specifics.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   AssertEqual(specifics, *all_device_info[0]);
-  AssertEqual(specifics, *service()->GetDeviceInfo("tag").get());
+  AssertEqual(specifics,
+              *service()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalMetadata) {
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
   InitializeAndPump();
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   ASSERT_TRUE(
       local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
   EXPECT_EQ(1u, processor()->put_map().size());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalDataAndMetadata) {
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics(GenerateTestSpecifics());
-  store()->WriteData(batch.get(), "tag", specifics.SerializeAsString());
+  store()->WriteData(batch.get(), specifics.cache_guid(),
+                     specifics.SerializeAsString());
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(2u, all_device_info.size());
-  AssertEqual(specifics, *service()->GetDeviceInfo("tag").get());
+  AssertEqual(specifics,
+              *service()->GetDeviceInfo(specifics.cache_guid()).get());
   ASSERT_TRUE(processor()->metadata());
   ASSERT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, GetData) {
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
+  DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics3(GenerateTestSpecifics());
-  store()->WriteData(batch.get(), "tag1", specifics1.SerializeAsString());
-  store()->WriteData(batch.get(), "tag2",
-                     GenerateTestSpecifics().SerializeAsString());
-  store()->WriteData(batch.get(), "tag3", specifics3.SerializeAsString());
+  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));
 
   InitializeAndPump();
 
   std::map<std::string, DeviceInfoSpecifics> expected;
-  expected["tag1"] = specifics1;
-  expected["tag3"] = specifics3;
+  expected[CacheGuidToTag(specifics1.cache_guid())] = specifics1;
+  expected[CacheGuidToTag(specifics3.cache_guid())] = specifics3;
   ClientTagList client_tags;
-  client_tags.push_back("tag1");
-  client_tags.push_back("tag3");
+  client_tags.push_back(CacheGuidToTag(specifics1.cache_guid()));
+  client_tags.push_back(CacheGuidToTag(specifics3.cache_guid()));
   service()->GetData(client_tags,
                      base::Bind(&AssertExpectedFromDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, GetDataMissing) {
   InitializeAndPump();
   std::map<std::string, DeviceInfoSpecifics> expected;
   ClientTagList client_tags;
-  client_tags.push_back("tag1");
+  client_tags.push_back(CacheGuidToTag("tag1"));
   service()->GetData(client_tags,
                      base::Bind(&AssertExpectedFromDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, GetDataNotInitialized) {
   InitializeService();
   ClientTagList client_tags;
   service()->GetData(client_tags, base::Bind(&AssertErrorFromDataBatch));
 }
 
 TEST_F(DeviceInfoServiceTest, GetAllData) {
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
-  store()->WriteData(batch.get(), "tag1", specifics1.SerializeAsString());
-  store()->WriteData(batch.get(), "tag2", specifics2.SerializeAsString());
+  const std::string& tag1 = CacheGuidToTag(specifics1.cache_guid());
+  const std::string& tag2 = CacheGuidToTag(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));
 
   InitializeAndPump();
 
   std::map<std::string, DeviceInfoSpecifics> expected;
-  expected["tag1"] = specifics1;
-  expected["tag2"] = specifics2;
+  expected[tag1] = specifics1;
+  expected[tag2] = specifics2;
   ClientTagList client_tags;
-  client_tags.push_back("tag1");
-  client_tags.push_back("tag2");
+  client_tags.push_back(tag1);
+  client_tags.push_back(tag2);
   service()->GetData(client_tags,
                      base::Bind(&AssertExpectedFromDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, GetAllDataNotInitialized) {
   InitializeService();
   service()->GetAllData(base::Bind(&AssertErrorFromDataBatch));
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesBeforeInit) {
@@ skipping 15 matching lines @@
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesInMemory) {
   InitializeAndPump();
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList add_changes;
   const std::string tag = PushBackEntityChangeAdd(specifics, &add_changes);
   SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), add_changes);
 
   EXPECT_FALSE(error.IsSet());
-  scoped_ptr<DeviceInfo> info = service()->GetDeviceInfo(tag);
+  scoped_ptr<DeviceInfo> info =
+      service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
   EXPECT_EQ(1, change_count());
 
   EntityChangeList delete_changes;
   delete_changes.push_back(EntityChange::CreateDelete(tag));
   error = service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                                       delete_changes);
 
   EXPECT_FALSE(error.IsSet());
-  EXPECT_FALSE(service()->GetDeviceInfo(tag));
+  EXPECT_FALSE(service()->GetDeviceInfo(specifics.cache_guid()));
   EXPECT_EQ(2, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesStore) {
   InitializeAndPump();
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList data_changes;
   const std::string tag = PushBackEntityChangeAdd(specifics, &data_changes);
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   scoped_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
   metadata_changes->UpdateDataTypeState(state);
 
   const SyncError error =
       service()->ApplySyncChanges(std::move(metadata_changes), data_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 
   PumpAndShutdown();
   InitializeAndPump();
 
-  scoped_ptr<DeviceInfo> info = service()->GetDeviceInfo(tag);
+  scoped_ptr<DeviceInfo> info =
+      service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
   // TODO(skym): Uncomment once SimpleMetadataChangeList::TransferChanges is
   // implemented.
   // EXPECT_TRUE(processor()->metadata());
   // EXPECT_EQ(state.encryption_key_name(),
   // processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesWithLocalGuid) {
   InitializeAndPumpAndStart();
 
   // 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;
   const std::string tag = PushBackEntityChangeAdd(specifics, &change_list);
 
   // Should have a single change from reconciliation.
-  EXPECT_TRUE(service()->GetDeviceInfo(tag));
+  EXPECT_TRUE(
+      service()->GetDeviceInfo(local_device()->GetLocalDeviceInfo()->guid()));
   EXPECT_EQ(1, change_count());
 
   EXPECT_FALSE(
       service()
           ->ApplySyncChanges(service()->CreateMetadataChangeList(), change_list)
           .IsSet());
   EXPECT_EQ(1, change_count());
 
   change_list.clear();
   change_list.push_back(EntityChange::CreateDelete(tag));
   EXPECT_FALSE(
       service()
           ->ApplySyncChanges(service()->CreateMetadataChangeList(), change_list)
           .IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplyDeleteNonexistent) {
   InitializeAndPumpAndStart();
   EXPECT_EQ(1, change_count());
   EntityChangeList delete_changes;
-  delete_changes.push_back(EntityChange::CreateDelete("tag"));
+  delete_changes.push_back(EntityChange::CreateDelete(CacheGuidToTag("tag")));
   const SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), delete_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeWithoutProcessor) {
   InitializeService();
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), EntityDataMap());
@@ skipping 23 matching lines @@
                      unique_local.SerializeAsString());
   store()->WriteData(batch.get(), conflict_local.cache_guid(),
                      conflict_local.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPumpAndStart();
   EXPECT_EQ(1, change_count());
 
   EntityDataMap remote_input;
-  remote_input[conflict_remote.cache_guid()] =
+  remote_input[CacheGuidToTag(conflict_remote.cache_guid())] =
       SpecificsToEntity(conflict_remote);
-  remote_input[unique_remote.cache_guid()] = SpecificsToEntity(unique_remote);
+  remote_input[CacheGuidToTag(unique_remote.cache_guid())] =
+      SpecificsToEntity(unique_remote);
 
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   scoped_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
   metadata_changes->UpdateDataTypeState(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, *service()->GetDeviceInfo("unique_local").get());
   AssertEqual(unique_remote, *service()->GetDeviceInfo("unique_remote").get());
   AssertEqual(conflict_remote, *service()->GetDeviceInfo("conflict").get());
 
   // Service should have told the processor about the existance of unique_local.
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_EQ(2u, processor()->put_map().size());
-  const auto& it = processor()->put_map().find("unique_local");
+  const auto& it = processor()->put_map().find(CacheGuidToTag("unique_local"));
   ASSERT_NE(processor()->put_map().end(), it);
   AssertEqual(unique_local, it->second->specifics.device_info());
 
   // TODO(skym): Uncomment once SimpleMetadataChangeList::TransferChanges is
   // implemented.
   // ASSERT_EQ(state.encryption_key_name(),
   // processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeLocalGuid) {
   const DeviceInfo* local_device_info = local_device()->GetLocalDeviceInfo();
   scoped_ptr<DeviceInfoSpecifics> specifics(
       CopyToSpecifics(*local_device_info));
-  const std::string tag = local_device_info->guid();
+  const std::string guid = local_device_info->guid();
 
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  store()->WriteData(batch.get(), tag, specifics->SerializeAsString());
+  store()->WriteData(batch.get(), guid, specifics->SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPumpAndStart();
 
   EntityDataMap remote_input;
-  remote_input[tag] = SpecificsToEntity(*specifics);
+  remote_input[CacheGuidToTag(guid)] = SpecificsToEntity(*specifics);
 
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(1u, service()->GetAllDeviceInfo().size());
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_TRUE(processor()->put_map().empty());
 }
 
 }  // namespace
 
 }  // namespace sync_driver_v2