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

components/sync_driver/device_info_sync_service_unittest.cc

 // Copyright 2014 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_sync_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 89 matching lines @@
     sync_service_.reset(new DeviceInfoSyncService(local_device_.get()));
     sync_processor_.reset(new TestChangeProcessor());
     // Register observer
     sync_service_->AddObserver(this);
   }
 
   void TearDown() override { sync_service_->RemoveObserver(this); }
 
   void OnDeviceInfoChange() override { num_device_info_changed_callbacks_++; }
 
-  scoped_ptr<SyncChangeProcessor> PassProcessor() {
-    return scoped_ptr<SyncChangeProcessor>(
+  std::unique_ptr<SyncChangeProcessor> PassProcessor() {
+    return std::unique_ptr<SyncChangeProcessor>(
         new SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   }
 
-  scoped_ptr<SyncErrorFactory> CreateAndPassSyncErrorFactory() {
-    return scoped_ptr<SyncErrorFactory>(new SyncErrorFactoryMock());
+  std::unique_ptr<SyncErrorFactory> CreateAndPassSyncErrorFactory() {
+    return std::unique_ptr<SyncErrorFactory>(new SyncErrorFactoryMock());
   }
 
   // Default |last_updated_timestamp| to now to avoid pulse update on merge.
   SyncData CreateRemoteData(const std::string& client_id,
                             const std::string& client_name,
                             Time last_updated_timestamp = Time::Now()) {
     sync_pb::EntitySpecifics entity;
     sync_pb::DeviceInfoSpecifics& specifics = *entity.mutable_device_info();
 
     specifics.set_cache_guid(client_id);
@@ skipping 36 matching lines @@
   void StoreSyncData(const std::string& client_id,
                      const syncer::SyncData& sync_data) {
     sync_service_->StoreSyncData(client_id, sync_data);
   }
   bool IsPulseTimerRunning() { return sync_service_->pulse_timer_.IsRunning(); }
 
   // Needs to be created for OneShotTimer to grab the current task runner.
   base::MessageLoop message_loop_;
 
   int num_device_info_changed_callbacks_;
-  scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
-  scoped_ptr<DeviceInfoSyncService> sync_service_;
-  scoped_ptr<TestChangeProcessor> sync_processor_;
+  std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
+  std::unique_ptr<DeviceInfoSyncService> sync_service_;
+  std::unique_ptr<TestChangeProcessor> sync_processor_;
 };
 
 namespace {
 
 // Sync with empty initial data.
 TEST_F(DeviceInfoSyncServiceTest, StartSyncEmptyInitialData) {
   EXPECT_FALSE(sync_service_->IsSyncing());
 
   SyncMergeResult merge_result =
       sync_service_->MergeDataAndStartSyncing(syncer::DEVICE_INFO,
@@ skipping 408 matching lines @@
   sync_pb::EntitySpecifics entity;
   sync_pb::DeviceInfoSpecifics& specifics = *entity.mutable_device_info();
   specifics.set_cache_guid("stale");
   StoreSyncData("stale", SyncData::CreateLocalData("stale", "stale", entity));
   EXPECT_EQ(0, CountActiveDevices(Time() + kStaleDeviceInfoThreshold));
 }
 
 }  // namespace
 
 }  // namespace sync_driver