[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/entity_data.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 76 matching lines @@
   // 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 {
+class FakeSharedModelTypeProcessor
+    : public syncer_v2::SharedModelTypeProcessor {

[maxbogue, 2016/03/22 21:40:12]

Why is this now an actual SharedModelTypeProcessor?

[Gang Wu, 2016/03/24 15:56:25]

Done.

  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 {

[maxbogue, 2016/03/22 21:40:12]

You shouldn't need this class. It's not adding any useful information...

[Gang Wu, 2016/03/24 15:56:25]

Done.

+ public:
+  FakeDeviceInfoService(
+      sync_driver::LocalDeviceInfoProvider* local_device_info_provider,
+      const StoreFactoryFunction& callback,
+      const SharedProcessorFactory& shared_processor_factory)
+      : DeviceInfoService(local_device_info_provider,
+                          callback,
+                          shared_processor_factory) {}
+  ~FakeDeviceInfoService() override{};
+  ModelTypeChangeProcessor* CreateProcessorForTest() {
+    return create_change_processor();
+  }
+};
+
 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> CreateSharedModelTypeProcessor(
+      syncer::ModelType type,
+      ModelTypeService* service) {
+    processor_ = new FakeSharedModelTypeProcessor(syncer::DEVICE_INFO, service);
+    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(
+    service_.reset(new FakeDeviceInfoService(
         local_device_.get(),
         base::Bind(&ModelTypeStoreTestUtil::MoveStoreToCallback,
-                   base::Passed(&store_))));
+                   base::Passed(&store_)),
+        base::Bind(&DeviceInfoServiceTest::CreateSharedModelTypeProcessor,
+                   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_));
+    EXPECT_EQ(processor_, service_->CreateProcessorForTest());
+    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 44 matching lines @@
     std::swap(local_device_, provider);
   }
   LocalDeviceInfoProviderMock* local_device() { return local_device_.get(); }
 
   // Allows access to the service after InitializeService() is called.
   DeviceInfoService* 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 347 matching lines @@
   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