[Sync] Create UserEventSyncBridge.

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 175 matching lines @@
     // Some tests may never initialize the bridge.
     if (bridge_)
       bridge_->RemoveObserver(this);
 
     // Force all remaining (store) tasks to execute so we don't leak memory.
     base::RunLoop().RunUntilIdle();
   }
 
   void OnDeviceInfoChange() override { change_count_++; }
 
-  std::unique_ptr<ModelTypeChangeProcessor> CreateModelTypeChangeProcessor(
-      ModelType type,
-      ModelTypeSyncBridge* bridge) {
-    auto processor = base::MakeUnique<RecordingModelTypeChangeProcessor>();
-    processor_ = processor.get();
-    return std::move(processor);
-  }
-
   // Initialized the bridge based on the current local device and store. Can
   // only be called once per run, as it passes |store_|.
   void InitializeBridge() {
     ASSERT_TRUE(store_);
     bridge_ = base::MakeUnique<DeviceInfoSyncBridge>(
         provider_.get(),
         base::Bind(&ModelTypeStoreTestUtil::MoveStoreToCallback,
                    base::Passed(&store_)),
-        base::Bind(&DeviceInfoSyncBridgeTest::CreateModelTypeChangeProcessor,
-                   base::Unretained(this)));
+        RecordingModelTypeChangeProcessor::FactoryForBridgeTest(&processor_));
     bridge_->AddObserver(this);
   }
 
   // Creates the bridge and runs any outstanding tasks. This will typically
   // cause all initialization callbacks between the sevice and store to fire.
   void InitializeAndPump() {
     InitializeBridge();
     base::RunLoop().RunUntilIdle();
   }
 
@@ skipping 13 matching lines @@
     std::swap(provider_, provider);
   }
   LocalDeviceInfoProviderMock* local_device() { return provider_.get(); }
 
   // Allows access to the bridge after InitializeBridge() is called.
   DeviceInfoSyncBridge* bridge() {
     EXPECT_TRUE(bridge_);
     return bridge_.get();
   }
 
-  RecordingModelTypeChangeProcessor* processor() {
-    EXPECT_TRUE(processor_);
-    return processor_;
-  }
+  const RecordingModelTypeChangeProcessor& processor() { return *processor_; }
 
   const OneShotTimer& pulse_timer() { return bridge()->pulse_timer_; }
 
   // Should only be called after the bridge has been initialized. Will first
   // recover the bridge's store, so another can be initialized later, and then
   // deletes the bridge.
   void PumpAndShutdown() {
     ASSERT_TRUE(bridge_);
     base::RunLoop().RunUntilIdle();
     std::swap(store_, bridge_->store_);
@@ skipping 81 matching lines @@
 
   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());
+  EXPECT_FALSE(processor().metadata());
 
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateModel(1));
   base::RunLoop().RunUntilIdle();
 
   DeviceInfoList devices = bridge()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
 
-  EXPECT_TRUE(processor()->metadata());
+  EXPECT_TRUE(processor().metadata());
 }
 
 // Simulate shutting down sync during the ModelTypeStore callbacks. The pulse
 // timer should still be initialized, even though reconcile never occurs.
 TEST_F(DeviceInfoSyncBridgeTest, ClearProviderDuringInit) {
   InitializeBridge();
   local_device()->Clear();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
   EXPECT_TRUE(pulse_timer().IsRunning());
@@ skipping 28 matching lines @@
               *bridge()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalMetadata) {
   WriteToStore(std::vector<DeviceInfoSpecifics>(), StateWithEncryption("ekn"));
   InitializeAndPump();
 
   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());
+  EXPECT_EQ(1u, processor().put_multimap().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalDataAndMetadata) {
   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_TRUE(processor().metadata());
   EXPECT_EQ(state.encryption_key_name(),
-            processor()->metadata()->GetModelTypeState().encryption_key_name());
+            processor().metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetData) {
   const DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
   const DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
   const DeviceInfoSpecifics specifics3 = CreateSpecifics(3);
   WriteToStore({specifics1, specifics2, specifics3});
   InitializeAndPump();
 
   const std::map<std::string, DeviceInfoSpecifics> expected{
@@ skipping 71 matching lines @@
   EXPECT_FALSE(error);
   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_TRUE(processor().metadata());
   EXPECT_EQ(state.encryption_key_name(),
-            processor()->metadata()->GetModelTypeState().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.
   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.
   const Time last_updated(ProtoTimeToTime(processor()
-                                              ->put_multimap()
+                                              .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);
 
   auto error_on_add = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
   EXPECT_FALSE(error_on_add);
   EXPECT_EQ(1, change_count());
@@ skipping 37 matching lines @@
 TEST_F(DeviceInfoSyncBridgeTest, MergeEmpty) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
   auto error = bridge()->MergeSyncData(bridge()->CreateMetadataChangeList(),
                                        EntityDataMap());
   EXPECT_FALSE(error);
   EXPECT_EQ(1, change_count());
   // TODO(skym): Stop sending local twice. The first of the two puts will
   // probably happen before the processor is tracking metadata yet, and so there
   // should not be much overhead.
-  EXPECT_EQ(2u, processor()->put_multimap().size());
-  EXPECT_EQ(2u, processor()->put_multimap().count(
+  EXPECT_EQ(2u, processor().put_multimap().size());
+  EXPECT_EQ(2u, processor().put_multimap().count(
                     local_device()->GetLocalDeviceInfo()->guid()));
-  EXPECT_EQ(0u, processor()->delete_set().size());
+  EXPECT_EQ(0u, processor().delete_set().size());
 }
 
 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);
@@ skipping 16 matching lines @@
 
   // 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);
+  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());
+            processor().metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuid) {
   // 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();
 
   auto error = bridge()->MergeSyncData(bridge()->CreateMetadataChangeList(),
                                        InlineEntityDataMap({specifics}));
   EXPECT_FALSE(error);
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
-  EXPECT_TRUE(processor()->delete_set().empty());
-  EXPECT_TRUE(processor()->put_multimap().empty());
+  EXPECT_TRUE(processor().delete_set().empty());
+  EXPECT_TRUE(processor().put_multimap().empty());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuidBeforeReconcile) {
   InitializeBridge();
 
   // 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.
   auto error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(),
@@ skipping 46 matching lines @@
 
   // Now set time to long ago in the past, it should not be active anymore.
   bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
                              EntityAddList({CreateSpecifics(1)}));
   EXPECT_EQ(1, bridge()->CountActiveDevices());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MultipleOnProviderInitialized) {
   set_provider(base::MakeUnique<LocalDeviceInfoProviderMock>());
   InitializeAndPump();
-  EXPECT_EQ(nullptr, processor()->metadata());
+  EXPECT_EQ(nullptr, processor().metadata());
 
   // Verify the processor was given metadata.
   local_device()->Initialize(CreateModel(0));
   base::RunLoop().RunUntilIdle();
-  const MetadataBatch* metadata = processor()->metadata();
+  const MetadataBatch* metadata = processor().metadata();
   EXPECT_NE(nullptr, metadata);
 
   // Pointer address of metadata should remain constant because the processor
   // should not have been given new metadata.
   local_device()->Initialize(CreateModel(0));
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(metadata, processor()->metadata());
+  EXPECT_EQ(metadata, processor().metadata());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, SendLocalData) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
-  EXPECT_EQ(1u, processor()->put_multimap().size());
+  EXPECT_EQ(1u, processor().put_multimap().size());
 
   ForcePulse();
   EXPECT_EQ(2, change_count());
-  EXPECT_EQ(2u, processor()->put_multimap().size());
+  EXPECT_EQ(2u, processor().put_multimap().size());
 
   // After clearing, pulsing should no-op and not result in a processor put or
   // a notification to observers.
   local_device()->Clear();
   ForcePulse();
   EXPECT_EQ(2, change_count());
-  EXPECT_EQ(2u, processor()->put_multimap().size());
+  EXPECT_EQ(2u, processor().put_multimap().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, DisableSync) {
   InitializeAndPump();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(1, change_count());
 
   const DeviceInfoSpecifics specifics = CreateSpecifics(1);
   auto error = bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
                                           EntityAddList({specifics}));
 
   EXPECT_FALSE(error);
   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