Convert //components/sync_driver from scoped_ptr to std::unique_ptr

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 <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.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/fake_model_type_change_processor.h"
 #include "sync/api/metadata_batch.h"
 #include "sync/api/model_type_store.h"
 #include "sync/internal_api/public/test/model_type_store_test_util.h"
@@ skipping 48 matching lines @@
                  const DeviceInfo& model) {
   ASSERT_EQ(specifics.cache_guid(), model.guid());
   ASSERT_EQ(specifics.client_name(), model.client_name());
   ASSERT_EQ(specifics.device_type(), model.device_type());
   ASSERT_EQ(specifics.sync_user_agent(), model.sync_user_agent());
   ASSERT_EQ(specifics.chrome_version(), model.chrome_version());
   ASSERT_EQ(specifics.signin_scoped_device_id(),
             model.signin_scoped_device_id());
 }
 
-void AssertErrorFromDataBatch(SyncError error, scoped_ptr<DataBatch> batch) {
+void AssertErrorFromDataBatch(SyncError error,
+                              std::unique_ptr<DataBatch> batch) {
   ASSERT_TRUE(error.IsSet());
 }
 
 void AssertExpectedFromDataBatch(
     std::map<std::string, DeviceInfoSpecifics> expected,
     SyncError error,
-    scoped_ptr<DataBatch> batch) {
+    std::unique_ptr<DataBatch> batch) {
   ASSERT_FALSE(error.IsSet());
   while (batch->HasNext()) {
     const TagAndData& pair = batch->Next();
     std::map<std::string, DeviceInfoSpecifics>::iterator iter =
         expected.find(pair.first);
     ASSERT_NE(iter, expected.end());
     AssertEqual(iter->second, pair.second->specifics.device_info());
     // Removing allows us to verify we don't see the same item multiple times,
     // and that we saw everything we expected.
     expected.erase(iter);
@@ skipping 21 matching lines @@
 // 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 RecordingModelTypeChangeProcessor
     : public syncer_v2::FakeModelTypeChangeProcessor {
  public:
   RecordingModelTypeChangeProcessor() {}
   ~RecordingModelTypeChangeProcessor() override {}
 
   void Put(const std::string& client_tag,
-           scoped_ptr<EntityData> entity_data,
+           std::unique_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);
   }
 
-  void OnMetadataLoaded(scoped_ptr<MetadataBatch> batch) override {
+  void OnMetadataLoaded(std::unique_ptr<MetadataBatch> batch) override {
     std::swap(metadata_, batch);
   }
 
-  const std::map<std::string, scoped_ptr<EntityData>>& put_map() const {
+  const std::map<std::string, std::unique_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::map<std::string, std::unique_ptr<EntityData>> put_map_;
   std::set<std::string> delete_set_;
-  scoped_ptr<MetadataBatch> metadata_;
+  std::unique_ptr<MetadataBatch> metadata_;
 };
 
 }  // namespace
 
 class DeviceInfoServiceTest : public testing::Test,
                               public DeviceInfoTracker::Observer {
  protected:
   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")) {}
 
   ~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_++; }
 
-  scoped_ptr<ModelTypeChangeProcessor> CreateModelTypeChangeProcessor(
+  std::unique_ptr<ModelTypeChangeProcessor> CreateModelTypeChangeProcessor(
       syncer::ModelType type,
       ModelTypeService* service) {
     processor_ = new RecordingModelTypeChangeProcessor();
-    return make_scoped_ptr(processor_);
+    return base::WrapUnique(processor_);
   }
 
   // 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_)),
@@ skipping 28 matching lines @@
     specifics.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
     specifics.set_sync_user_agent(
         base::StringPrintf("sync user agent %d", label));
     specifics.set_chrome_version(
         base::StringPrintf("chrome version %d", label));
     specifics.set_signin_scoped_device_id(
         base::StringPrintf("signin scoped device id %d", label));
     return specifics;
   }
 
-  scoped_ptr<DeviceInfoSpecifics> CopyToSpecifics(const DeviceInfo& info) {
+  std::unique_ptr<DeviceInfoSpecifics> CopyToSpecifics(const DeviceInfo& info) {
     return DeviceInfoService::CopyToSpecifics(info);
   }
 
   // Override to allow specific cache guids.
   DeviceInfoSpecifics GenerateTestSpecifics(const std::string& guid) {
     DeviceInfoSpecifics specifics(GenerateTestSpecifics());
     specifics.set_cache_guid(guid);
     return specifics;
   }
 
@@ skipping 14 matching lines @@
   // initialize the service.
   ModelTypeStore* store() {
     EXPECT_TRUE(store_);
     return store_.get();
   }
 
   // Get the number of times the service notifies observers of changes.
   int change_count() { return change_count_; }
 
   // Allows overriding the provider before the service is initialized.
-  void set_local_device(scoped_ptr<LocalDeviceInfoProviderMock> provider) {
+  void set_local_device(std::unique_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() {
     EXPECT_TRUE(service_);
     return service_.get();
   }
@@ skipping 17 matching lines @@
  private:
   int change_count_;
 
   // Although we never use this in this class, the in memory model type store
   // grabs the current task runner from a static accessor which point at this
   // message loop. Must be declared/initilized before we call the synchronous
   // CreateInMemoryStoreForTest.
   base::MessageLoop message_loop_;
 
   // Holds the store while the service is not initialized.
-  scoped_ptr<ModelTypeStore> store_;
+  std::unique_ptr<ModelTypeStore> store_;
 
-  scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
+  std::unique_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_;
+  std::unique_ptr<DeviceInfoService> 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.
   RecordingModelTypeChangeProcessor* processor_ = nullptr;
 
   // A monotonically increasing label for generated specifics objects with data
   // that is slightly different from eachother.
   int generated_count_ = 0;
 };
 
@@ skipping 14 matching lines @@
   service()->OnSyncStarting(StartCallback());
   ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
   base::RunLoop().RunUntilIdle();
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   ASSERT_TRUE(
       local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
 }
 
 TEST_F(DeviceInfoServiceTest, LocalProviderSubscription) {
-  set_local_device(make_scoped_ptr(new LocalDeviceInfoProviderMock()));
+  set_local_device(base::WrapUnique(new LocalDeviceInfoProviderMock()));
   InitializeAndPumpAndStart();
   ASSERT_EQ(0u, service()->GetAllDeviceInfo().size());
-  local_device()->Initialize(make_scoped_ptr(
+  local_device()->Initialize(base::WrapUnique(
       new DeviceInfo("guid_1", "client_1", "Chromium 10k", "Chrome 10k",
                      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id")));
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   ASSERT_TRUE(
       local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
 }
 
 TEST_F(DeviceInfoServiceTest, GetClientTagNormal) {
   InitializeService();
   const std::string guid = "abc";
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info()->set_cache_guid(guid);
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(guid), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, GetClientTagEmpty) {
   InitializeService();
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info();
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(""), service()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalData) {
-  scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
+  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics(GenerateTestSpecifics());
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   AssertEqual(specifics, *all_device_info[0]);
   AssertEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalMetadata) {
-  scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
+  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
   InitializeAndPump();
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   ASSERT_TRUE(
       local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
   EXPECT_EQ(1u, processor()->put_map().size());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalDataAndMetadata) {
-  scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
+  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics(GenerateTestSpecifics());
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
   DataTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
   ScopedVector<DeviceInfo> all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(2u, all_device_info.size());
   AssertEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
   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();
+  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics3(GenerateTestSpecifics());
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
                      specifics2.SerializeAsString());
   store()->WriteData(batch.get(), specifics3.cache_guid(),
                      specifics3.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
@@ skipping 20 matching lines @@
                      base::Bind(&AssertExpectedFromDataBatch, expected));
 }
 
 TEST_F(DeviceInfoServiceTest, GetDataNotInitialized) {
   InitializeService();
   ClientTagList client_tags;
   service()->GetData(client_tags, base::Bind(&AssertErrorFromDataBatch));
 }
 
 TEST_F(DeviceInfoServiceTest, GetAllData) {
-  scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
+  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
   const std::string& tag1 = CacheGuidToTag(specifics1.cache_guid());
   const std::string& tag2 = CacheGuidToTag(specifics2.cache_guid());
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
                      specifics2.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
@@ skipping 34 matching lines @@
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesInMemory) {
   InitializeAndPump();
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList add_changes;
   const std::string tag = PushBackEntityChangeAdd(specifics, &add_changes);
   SyncError error = service()->ApplySyncChanges(
       service()->CreateMetadataChangeList(), add_changes);
 
   EXPECT_FALSE(error.IsSet());
-  scoped_ptr<DeviceInfo> info =
+  std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
   EXPECT_EQ(1, change_count());
 
   EntityChangeList delete_changes;
   delete_changes.push_back(EntityChange::CreateDelete(tag));
   error = service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                                       delete_changes);
 
   EXPECT_FALSE(error.IsSet());
   EXPECT_FALSE(service()->GetDeviceInfo(specifics.cache_guid()));
   EXPECT_EQ(2, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesStore) {
   InitializeAndPump();
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList data_changes;
   const std::string tag = PushBackEntityChangeAdd(specifics, &data_changes);
   DataTypeState state;
   state.set_encryption_key_name("ekn");
-  scoped_ptr<MetadataChangeList> metadata_changes(
+  std::unique_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
   metadata_changes->UpdateDataTypeState(state);
 
   const SyncError error =
       service()->ApplySyncChanges(std::move(metadata_changes), data_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 
   PumpAndShutdown();
   InitializeAndPump();
 
-  scoped_ptr<DeviceInfo> info =
+  std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
   // TODO(skym): Uncomment once SimpleMetadataChangeList::TransferChanges is
   // implemented.
   // EXPECT_TRUE(processor()->metadata());
   // EXPECT_EQ(state.encryption_key_name(),
   // processor()->metadata()->GetDataTypeState().encryption_key_name());
 }
 
@@ skipping 57 matching lines @@
   EXPECT_EQ(1u, processor()->put_map().size());
   EXPECT_EQ(0u, processor()->delete_set().size());
 }
 
 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();
+  std::unique_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));
 
   InitializeAndPumpAndStart();
   EXPECT_EQ(1, change_count());
 
   EntityDataMap remote_input;
   remote_input[CacheGuidToTag(conflict_remote.cache_guid())] =
       SpecificsToEntity(conflict_remote);
   remote_input[CacheGuidToTag(unique_remote.cache_guid())] =
       SpecificsToEntity(unique_remote);
 
   DataTypeState state;
   state.set_encryption_key_name("ekn");
-  scoped_ptr<MetadataChangeList> metadata_changes(
+  std::unique_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
   metadata_changes->UpdateDataTypeState(state);
 
   const SyncError error =
       service()->MergeSyncData(std::move(metadata_changes), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   // The remote should beat the local in conflict.
   EXPECT_EQ(4u, service()->GetAllDeviceInfo().size());
   AssertEqual(unique_local, *service()->GetDeviceInfo("unique_local").get());
   AssertEqual(unique_remote, *service()->GetDeviceInfo("unique_remote").get());
   AssertEqual(conflict_remote, *service()->GetDeviceInfo("conflict").get());
 
   // Service should have told the processor about the existance of unique_local.
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_EQ(2u, processor()->put_map().size());
   const auto& it = processor()->put_map().find(CacheGuidToTag("unique_local"));
   ASSERT_NE(processor()->put_map().end(), it);
   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) {
   const DeviceInfo* local_device_info = local_device()->GetLocalDeviceInfo();
-  scoped_ptr<DeviceInfoSpecifics> specifics(
+  std::unique_ptr<DeviceInfoSpecifics> specifics(
       CopyToSpecifics(*local_device_info));
   const std::string guid = local_device_info->guid();
 
-  scoped_ptr<WriteBatch> batch = store()->CreateWriteBatch();
+  std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   store()->WriteData(batch.get(), guid, specifics->SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPumpAndStart();
 
   EntityDataMap remote_input;
   remote_input[CacheGuidToTag(guid)] = SpecificsToEntity(*specifics);
 
   const SyncError error = service()->MergeSyncData(
       service()->CreateMetadataChangeList(), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(1u, service()->GetAllDeviceInfo().size());
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_TRUE(processor()->put_map().empty());
 }
 
 }  // namespace
 
 }  // namespace sync_driver_v2