[Sync] DeviceInfo implementation of MergeSyncData.

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>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync_driver/local_device_info_provider_mock.h"
 #include "sync/api/data_batch.h"
+#include "sync/api/entity_data.h"
 #include "sync/api/metadata_batch.h"
 #include "sync/api/model_type_store.h"
 #include "sync/internal_api/public/test/model_type_store_test_util.h"
 #include "sync/protocol/data_type_state.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_driver_v2 {
 
 using syncer::SyncError;
 using syncer_v2::DataBatch;
 using syncer_v2::EntityChange;
 using syncer_v2::EntityChangeList;
 using syncer_v2::EntityData;
+using syncer_v2::EntityDataMap;
 using syncer_v2::EntityDataPtr;
 using syncer_v2::MetadataBatch;
 using syncer_v2::MetadataChangeList;
 using syncer_v2::ModelTypeChangeProcessor;
 using syncer_v2::ModelTypeService;
 using syncer_v2::ModelTypeStore;
 using syncer_v2::ModelTypeStoreTestUtil;
 using syncer_v2::TagAndData;
 using sync_driver::DeviceInfo;
 using sync_driver::DeviceInfoTracker;
@@ skipping 48 matching lines @@
         expected.find(pair.first);
     ASSERT_NE(iter, expected.end());
     AssertEqual(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());
 }
 
+// Creats 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();
+}
+
 // 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 FakeModelTypeChangeProcessor : public ModelTypeChangeProcessor {
  public:
   FakeModelTypeChangeProcessor() {}
   ~FakeModelTypeChangeProcessor() override {}
 
   void Put(const std::string& client_tag,
@@ skipping 89 matching lines @@
     specifics.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
     specifics.set_sync_user_agent(
         base::StringPrintf("sync user agent %d", label));
     specifics.set_chrome_version(
         base::StringPrintf("chrome version %d", label));
     specifics.set_signin_scoped_device_id(
         base::StringPrintf("signin scoped device id %d", label));
     return specifics;
   }
 
+  // Override to allow specific cache guids.
+  DeviceInfoSpecifics GenerateTestSpecifics(const std::string& guid) {
+    DeviceInfoSpecifics specifics(GenerateTestSpecifics());
+    specifics.set_cache_guid(guid);
+    return specifics;
+  }
+
   // 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 client tag the
   // service determines is returned. Instance method because we need access to
   // service to generate the tag.
   std::string PushBackEntityChangeAdd(const DeviceInfoSpecifics& specifics,
                                       EntityChangeList* changes) {
-    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;
-    const std::string tag = service()->GetClientTag(data);
-    changes->push_back(EntityChange::CreateAdd(tag, data.PassToPtr()));
+    EntityDataPtr ptr = SpecificsToEntity(specifics);
+    const std::string tag = service()->GetClientTag(ptr.value());
+    changes->push_back(EntityChange::CreateAdd(tag, ptr));
     return tag;
   }
 
   // Allows access to the store before that will ultimately be used to
   // initialize the service.
   ModelTypeStore* store() {
     EXPECT_TRUE(store_);
     return store_.get();
   }
 
@@ skipping 295 matching lines @@
   // EXPECT_EQ(state.encryption_key_name(),
   // processor()->metadata()->GetDataTypeState().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();
-  specifics.set_cache_guid(local_device()->GetLocalDeviceInfo()->guid());
+  DeviceInfoSpecifics specifics =
+      GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
 
   EntityChangeList data_changes;
   const std::string tag = PushBackEntityChangeAdd(specifics, &data_changes);
   const SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), data_changes);
 
   EXPECT_FALSE(error.IsSet());
   EXPECT_FALSE(service()->GetDeviceInfo(tag));
   EXPECT_EQ(0, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplyDeleteNonexistent) {
   InitializeAndPump();
   EntityChangeList delete_changes;
   delete_changes.push_back(EntityChange::CreateDelete("tag"));
   const SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), delete_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
 }
 
+TEST_F(DeviceInfoServiceTest, MergeBeforeInit) {
+  InitializeService();
+  const SyncError error = service()->MergeSyncData(
+      service()->CreateMetadataChangeList(), EntityDataMap());
+  EXPECT_TRUE(error.IsSet());
+  EXPECT_EQ(0, change_count());
+}
+
+TEST_F(DeviceInfoServiceTest, MergeEmpty) {
+  InitializeAndPump();
+  SetProcessorAndPump();
+  const SyncError error = service()->MergeSyncData(
+      service()->CreateMetadataChangeList(), EntityDataMap());
+  EXPECT_FALSE(error.IsSet());
+  EXPECT_EQ(0, change_count());
+}
+
+TEST_F(DeviceInfoServiceTest, MergeWithData) {
+  const DeviceInfoSpecifics unique_local(GenerateTestSpecifics("unique_local"));
+  const DeviceInfoSpecifics conflict_local(GenerateTestSpecifics("conflict"));
+  DeviceInfoSpecifics conflict_remote(GenerateTestSpecifics("conflict"));
+  DeviceInfoSpecifics unique_remote(GenerateTestSpecifics("unique_remote"));
+
+  scoped_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));
+
+  InitializeAndPump();
+  SetProcessorAndPump();
+
+  EntityDataMap remote_input;
+  remote_input[conflict_remote.cache_guid()] =
+      SpecificsToEntity(conflict_remote);
+  remote_input[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(1, change_count());
+
+  // The remote should beat the local in conflict.
+  EXPECT_EQ(3u, 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(1u, processor()->put_map().size());
+  const auto& it = processor()->put_map().find("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) {
+  InitializeAndPump();
+  SetProcessorAndPump();
+
+  // Service should ignore this because it uses the local device's guid.
+  DeviceInfoSpecifics specifics(
+      GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid()));
+  EntityDataMap remote_input;
+  remote_input[specifics.cache_guid()] = SpecificsToEntity(specifics);
+
+  const SyncError error = service()->MergeSyncData(
+      service()->CreateMetadataChangeList(), remote_input);
+  EXPECT_FALSE(error.IsSet());
+  EXPECT_EQ(0, change_count());
+  EXPECT_TRUE(service()->GetAllDeviceInfo().empty());
+  EXPECT_TRUE(processor()->delete_set().empty());
+  EXPECT_TRUE(processor()->put_map().empty());
+}
+
 }  // namespace
 
 }  // namespace sync_driver_v2