[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>
 
 #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/metadata_batch.h"
 #include "sync/api/model_type_store.h"
+#include "sync/internal_api/public/shared_model_type_processor.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;
@@ skipping 63 matching lines @@
     // and that we saw everything we expected.
     expected.erase(iter);
   }
   ASSERT_TRUE(expected.empty());
 }
 
 // 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 {
+class FakeSharedModelTypeProcessor
+    : public syncer_v2::SharedModelTypeProcessor {
  public:
-  FakeModelTypeChangeProcessor() {}
-  ~FakeModelTypeChangeProcessor() override {}
+  FakeSharedModelTypeProcessor(syncer::ModelType type,
+                               ModelTypeService* service)
+      : SharedModelTypeProcessor(type, service) {}
+  ~FakeSharedModelTypeProcessor() override {}
 
   void Put(const std::string& client_tag,
            scoped_ptr<EntityData> entity_data,
            MetadataChangeList* metadata_changes) override {
     put_map_.insert(std::make_pair(client_tag, std::move(entity_data)));
   }
 
   void Delete(const std::string& client_tag,
               MetadataChangeList* metadata_changes) override {
     delete_set_.insert(client_tag);
@@ skipping 10 matching lines @@
   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 FakeDeviceInfoService : public DeviceInfoService {
+ public:
+  FakeDeviceInfoService(
+      sync_driver::LocalDeviceInfoProvider* local_device_info_provider,
+      const StoreFactoryFunction& callback)
+      : DeviceInfoService(local_device_info_provider, callback){};
+  ~FakeDeviceInfoService() override{};
+
+  void set_processor(FakeSharedModelTypeProcessor* processor) {
+    processor_ = processor;
+  }
+
+ protected:
+  scoped_ptr<syncer_v2::SharedModelTypeProcessor>
+  CreateSharedModelTypeProcessor(syncer::ModelType type) override {
+    return make_scoped_ptr(processor_);
+  }
+
+ private:
+  FakeSharedModelTypeProcessor* processor_ = nullptr;
+};
+
 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();
@@ skipping 10 matching lines @@
             "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(
+    service_.reset(new FakeDeviceInfoService(
         local_device_.get(),
         base::Bind(&ModelTypeStoreTestUtil::MoveStoreToCallback,
                    base::Passed(&store_))));
     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() {

[skym, 2016/03/04 22:12:28]

I don't think we need this method anymore. Originally we assumed the processor
creation was being driving from something outside the service, and that's
essentially what this method did. But now, the service drives that, so there's
not reason to call this method.

[Gang Wu, 2016/03/08 20:35:24]

Will update where to trigger initial processor in next CL since it will require
some works.

-    processor_ = new FakeModelTypeChangeProcessor();
-    service()->set_change_processor(make_scoped_ptr(processor_));
+    processor_ =
+        new FakeSharedModelTypeProcessor(syncer::DEVICE_INFO, service());
+    service()->set_processor(processor_);
+    service()->InitializeProcessor(syncer::DEVICE_INFO);
     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 38 matching lines @@
   int change_count() { return change_count_; }
 
   // Allows overriding the provider before the service is initialized.
   void set_local_device(scoped_ptr<LocalDeviceInfoProviderMock> provider) {
     ASSERT_FALSE(service_);
     std::swap(local_device_, provider);
   }
   LocalDeviceInfoProviderMock* local_device() { return local_device_.get(); }
 
   // Allows access to the service after InitializeService() is called.
-  DeviceInfoService* service() {
+  FakeDeviceInfoService* service() {
     EXPECT_TRUE(service_);
     return service_.get();
   }
 
-  FakeModelTypeChangeProcessor* processor() {
+  FakeSharedModelTypeProcessor* processor() {
     EXPECT_TRUE(processor_);
     return processor_;
   }
 
   // Should only be called after the service has been initialized. Will first
   // recover the service's store, so another can be initialized later, and then
   // deletes the service.
   void ShutdownService() {
     ASSERT_TRUE(service_);
     std::swap(store_, service_->store_);
@@ skipping 10 matching lines @@
   // CreateInMemoryStoreForTest.
   base::MessageLoop message_loop_;
 
   // Holds the store while the service is not initialized.
   scoped_ptr<ModelTypeStore> store_;
 
   scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
 
   // Not initialized immediately (upon test's constructor). This allows each
   // test case to modify the dependencies the service will be constructed with.
-  scoped_ptr<DeviceInfoService> service_;
+  scoped_ptr<FakeDeviceInfoService> service_;
 
   // A non-owning pointer to the processor given to the service. Will be nullptr
   // before being given to the service, to make ownership easier.
-  FakeModelTypeChangeProcessor* processor_ = nullptr;
+  FakeSharedModelTypeProcessor* processor_ = nullptr;
 
   // A monotonically increasing label for generated specifics objects with data
   // that is slightly different from eachother.
   int generated_count_ = 0;
 };
 
 namespace {
 
 TEST_F(DeviceInfoServiceTest, EmptyDataReconciliation) {
   InitializeService();
@@ skipping 259 matching lines @@
   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());
 }
 
 }  // namespace
 
 }  // namespace sync_driver_v2