[USS] Change the place where SharedModelTypeProcessor got created

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 117 matching lines @@
 
   void Delete(const std::string& client_tag,
               MetadataChangeList* metadata_changes) override {
     delete_set_.insert(client_tag);
   }
 
   void OnMetadataLoaded(scoped_ptr<MetadataBatch> batch) override {
     std::swap(metadata_, batch);
   }
 
+  void OnSyncStarting(const StartCallback& callback) override {}
+
   const std::map<std::string, scoped_ptr<EntityData>>& put_map() const {
     return put_map_;
   }
   const std::set<std::string>& delete_set() const { return delete_set_; }
   const MetadataBatch* metadata() const { return metadata_.get(); }
 
  private:
   std::map<std::string, scoped_ptr<EntityData>> put_map_;
   std::set<std::string> delete_set_;
   scoped_ptr<MetadataBatch> metadata_;
 };
 
 }  // namespace
 
 class DeviceInfoServiceTest : public testing::Test,
                               public DeviceInfoTracker::Observer {
  protected:
   ~DeviceInfoServiceTest() override {
     // Some tests may never initialize the service.
     if (service_)
       service_->RemoveObserver(this);
 
     // Force all remaining (store) tasks to execute so we don't leak memory.
     base::RunLoop().RunUntilIdle();
   }
 
   void OnDeviceInfoChange() override { change_count_++; }
 
- protected:
+  scoped_ptr<ModelTypeChangeProcessor> CreateModelTypeChangeProcessor(
+      syncer::ModelType type,
+      ModelTypeService* service) {
+    processor_ = new FakeModelTypeChangeProcessor();
+    return make_scoped_ptr(processor_);
+  }
+
   DeviceInfoServiceTest()
       : change_count_(0),
         store_(ModelTypeStoreTestUtil::CreateInMemoryStoreForTest()),
         local_device_(new LocalDeviceInfoProviderMock(
             "guid_1",
             "client_1",
             "Chromium 10k",
             "Chrome 10k",
             sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
             "device_id")) {}
 
   // Initialized the service based on the current local device and store. Can
   // only be called once per run, as it passes |store_|.
   void InitializeService() {
     ASSERT_TRUE(store_);
     service_.reset(new DeviceInfoService(
         local_device_.get(),
         base::Bind(&ModelTypeStoreTestUtil::MoveStoreToCallback,
-                   base::Passed(&store_))));
+                   base::Passed(&store_)),
+        base::Bind(&DeviceInfoServiceTest::CreateModelTypeChangeProcessor,
+                   base::Unretained(this))));
     service_->AddObserver(this);
   }
 
   // Creates the service and runs any outstanding tasks. This will typically
   // cause all initialization callbacks between the sevice and store to fire.
   void InitializeAndPump() {
     InitializeService();
     base::RunLoop().RunUntilIdle();
   }
 
   // Creates a new processor and sets it on the service. We typically need to
   // pump in this scenario because metadata is going to need to be loading from
   // the store and given to the processor, which is async.
-  void SetProcessorAndPump() {
-    processor_ = new FakeModelTypeChangeProcessor();
-    service()->set_change_processor(make_scoped_ptr(processor_));
+  void CreateProcessorAndPump() {
+    // TODO(skym): Shouldn't need to directly force processor creation anymore.
+    EXPECT_EQ(processor_, service_->GetOrCreateChangeProcessor());
+    ASSERT_TRUE(processor_);
     base::RunLoop().RunUntilIdle();
   }
 
   // Generates a specifics object with slightly differing values. Will generate
   // the same values on each run of a test because a simple counter is used to
   // vary field values.
   DeviceInfoSpecifics GenerateTestSpecifics() {
     int label = ++generated_count_;
     DeviceInfoSpecifics specifics;
     specifics.set_cache_guid(base::StringPrintf("cache guid %d", label));
@@ skipping 161 matching lines @@
 
   InitializeAndPump();
 
   // Verify that we have data. We do this because we're testing that the service
   // may sometimes come up after our store init is fully completed.
   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());
 
-  SetProcessorAndPump();
+  CreateProcessorAndPump();
   ASSERT_TRUE(processor()->metadata());
   ASSERT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, TestInitProcBeforeStoreFinishes) {
   scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics(GenerateTestSpecifics());
   store()->WriteData(batch.get(), "tag", specifics.SerializeAsString());
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeService();
   // Verify we have _NO_ data yet, to verify that we're testing when the
   // processor is attached and ready before our store init is fully completed.
   ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
 
-  SetProcessorAndPump();
+  CreateProcessorAndPump();
   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 specifics3(GenerateTestSpecifics());
   store()->WriteData(batch.get(), "tag1", specifics1.SerializeAsString());
@@ skipping 112 matching lines @@
 
   const SyncError error =
       service()->ApplySyncChanges(std::move(metadata_changes), data_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 
   // Force write/commit tasks to finish before shutdown.
   base::RunLoop().RunUntilIdle();
   ShutdownService();
   InitializeAndPump();
-  SetProcessorAndPump();
+  CreateProcessorAndPump();
 
   scoped_ptr<DeviceInfo> info = service()->GetDeviceInfo(tag);
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
   EXPECT_TRUE(processor()->metadata());
   // TODO(skym): Uncomment once SimpleMetadataChangeList::TransferChanges is
   // implemented.
   // EXPECT_EQ(state.encryption_key_name(),
   // processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
@@ skipping 30 matching lines @@
 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();
+  CreateProcessorAndPump();
   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();
+  CreateProcessorAndPump();
 
   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());
@@ skipping 18 matching lines @@
   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();
+  CreateProcessorAndPump();
 
   // 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