[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 96 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> CreateSharedModelTypeProcessor(
+      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::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_->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 447 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