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

components/sync_driver/device_info_sync_service.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 <algorithm>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "components/sync_driver/local_device_info_provider.h"
 #include "sync/api/sync_change.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/util/time.h"
 
 namespace sync_driver {
 
@@ skipping 48 matching lines @@
     : local_device_info_provider_(local_device_info_provider) {
   DCHECK(local_device_info_provider);
 }
 
 DeviceInfoSyncService::~DeviceInfoSyncService() {
 }
 
 SyncMergeResult DeviceInfoSyncService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
-    scoped_ptr<SyncChangeProcessor> sync_processor,
-    scoped_ptr<SyncErrorFactory> error_handler) {
+    std::unique_ptr<SyncChangeProcessor> sync_processor,
+    std::unique_ptr<SyncErrorFactory> error_handler) {
   DCHECK(sync_processor.get());
   DCHECK(error_handler.get());
   DCHECK_EQ(type, syncer::DEVICE_INFO);
 
   DCHECK(!IsSyncing());
 
   sync_processor_ = std::move(sync_processor);
   error_handler_ = std::move(error_handler);
 
   // Initialization should be completed before this type is enabled
@@ skipping 14 matching lines @@
   // Iterate over all initial sync data and copy it to the cache.
   for (SyncDataList::const_iterator iter = initial_sync_data.begin();
        iter != initial_sync_data.end();
        ++iter) {
     DCHECK_EQ(syncer::DEVICE_INFO, iter->GetDataType());
 
     const std::string& id = iter->GetSpecifics().device_info().cache_guid();
 
     if (id == local_device_info->guid()) {
       // |initial_sync_data| contains data matching the local device.
-      scoped_ptr<DeviceInfo> synced_local_device_info =
-          make_scoped_ptr(CreateDeviceInfo(*iter));
+      std::unique_ptr<DeviceInfo> synced_local_device_info =
+          base::WrapUnique(CreateDeviceInfo(*iter));
 
       // TODO(pavely): Remove histogram once device_id mismatch is understood
       // (crbug/481596).
       if (synced_local_device_info->signin_scoped_device_id() !=
           local_device_info->signin_scoped_device_id()) {
         RecordDeviceIdChangedHistogram(
             synced_local_device_info->signin_scoped_device_id(),
             local_device_info->signin_scoped_device_id());
       }
 
@@ skipping 112 matching lines @@
     }
   }
 
   if (has_changes) {
     NotifyObservers();
   }
 
   return error;
 }
 
-scoped_ptr<DeviceInfo> DeviceInfoSyncService::GetDeviceInfo(
+std::unique_ptr<DeviceInfo> DeviceInfoSyncService::GetDeviceInfo(
     const std::string& client_id) const {
   SyncDataMap::const_iterator iter = all_data_.find(client_id);
   if (iter == all_data_.end()) {
-    return scoped_ptr<DeviceInfo>();
+    return std::unique_ptr<DeviceInfo>();
   }
 
-  return make_scoped_ptr(CreateDeviceInfo(iter->second));
+  return base::WrapUnique(CreateDeviceInfo(iter->second));
 }
 
 ScopedVector<DeviceInfo> DeviceInfoSyncService::GetAllDeviceInfo() const {
   ScopedVector<DeviceInfo> list;
 
   for (SyncDataMap::const_iterator iter = all_data_.begin();
        iter != all_data_.end();
        ++iter) {
     list.push_back(CreateDeviceInfo(iter->second));
   }
@@ skipping 131 matching lines @@
   for (const auto& pair : all_data_) {
     const TimeDelta age = GetLastUpdateAge(pair.second, now);
     if (age < kStaleDeviceInfoThreshold) {
       count++;
     }
   }
   return count;
 }
 
 }  // namespace sync_driver