Re-write many calls to WrapUnique() with MakeUnique()

components/sync/device_info/device_info_service.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/device_info/device_info_service.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 56 matching lines @@
   }
 
   callback.Run(base::Bind(&DeviceInfoService::OnStoreCreated,
                           weak_factory_.GetWeakPtr()));
 }
 
 DeviceInfoService::~DeviceInfoService() {}
 
 std::unique_ptr<MetadataChangeList>
 DeviceInfoService::CreateMetadataChangeList() {
-  return base::WrapUnique(new SimpleMetadataChangeList());
+  return base::MakeUnique<SimpleMetadataChangeList>();
 }
 
 SyncError DeviceInfoService::MergeSyncData(
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     EntityDataMap entity_data_map) {
   DCHECK(has_provider_initialized_);
   DCHECK(has_metadata_loaded_);
   DCHECK(change_processor());
 
   // Local data should typically be near empty, with the only possible value
@@ skipping 22 matching lines @@
       } else {
         // This device is valid right now and this entry is about to be
         // committed, use this as an opportunity to refresh the timestamp.
         all_data_[local_guid]->set_last_updated_timestamp(
             syncer::TimeToProtoTime(Time::Now()));
       }
     } else {
       // Remote data wins conflicts.
       local_guids_to_put.erase(specifics.cache_guid());
       has_changes = true;
-      StoreSpecifics(base::WrapUnique(new DeviceInfoSpecifics(specifics)),
+      StoreSpecifics(base::MakeUnique<DeviceInfoSpecifics>(specifics),
                      batch.get());
     }
   }
 
   for (const std::string& guid : local_guids_to_put) {
     change_processor()->Put(guid, CopyToEntityData(*all_data_[guid]),
                             metadata_change_list.get());
   }
 
   CommitAndNotify(std::move(batch), std::move(metadata_change_list),
@@ skipping 16 matching lines @@
     if (guid == local_device_info_provider_->GetLocalDeviceInfo()->guid()) {
       continue;
     }
 
     if (change.type() == EntityChange::ACTION_DELETE) {
       has_changes |= DeleteSpecifics(guid, batch.get());
     } else {
       const DeviceInfoSpecifics& specifics =
           change.data().specifics.device_info();
       DCHECK(guid == specifics.cache_guid());
-      StoreSpecifics(base::WrapUnique(new DeviceInfoSpecifics(specifics)),
+      StoreSpecifics(base::MakeUnique<DeviceInfoSpecifics>(specifics),
                      batch.get());
       has_changes = true;
     }
   }
 
   CommitAndNotify(std::move(batch), std::move(metadata_change_list),
                   has_changes);
   return SyncError();
 }
 
@@ skipping 37 matching lines @@
 
 void DeviceInfoService::OnChangeProcessorSet() {
   // We've recieved a new processor that needs metadata. If we're still in the
   // process of loading data and/or metadata, then |has_metadata_loaded_| is
   // false and we'll wait for those async reads to happen. If we've already
   // loaded metadata and then subsequently we get a new processor, we must not
   // have created the processor ourselves because we had no metadata. So there
   // must not be any metadata on disk.
   if (has_metadata_loaded_) {
     change_processor()->OnMetadataLoaded(SyncError(),
-                                         base::WrapUnique(new MetadataBatch()));
+                                         base::MakeUnique<MetadataBatch>());
     ReconcileLocalAndStored();
   }
 }
 
 bool DeviceInfoService::IsSyncing() const {
   return !all_data_.empty();
 }
 
 std::unique_ptr<DeviceInfo> DeviceInfoService::GetDeviceInfo(
     const std::string& client_id) const {
@@ skipping 42 matching lines @@
   specifics->set_chrome_version(info.chrome_version());
   specifics->set_sync_user_agent(info.sync_user_agent());
   specifics->set_device_type(info.device_type());
   specifics->set_signin_scoped_device_id(info.signin_scoped_device_id());
   return specifics;
 }
 
 // Static.
 std::unique_ptr<DeviceInfo> DeviceInfoService::CopyToModel(
     const DeviceInfoSpecifics& specifics) {
-  return base::WrapUnique(new DeviceInfo(
+  return base::MakeUnique<DeviceInfo>(
       specifics.cache_guid(), specifics.client_name(),
       specifics.chrome_version(), specifics.sync_user_agent(),
-      specifics.device_type(), specifics.signin_scoped_device_id()));
+      specifics.device_type(), specifics.signin_scoped_device_id());
 }
 
 // Static.
 std::unique_ptr<EntityData> DeviceInfoService::CopyToEntityData(
     const DeviceInfoSpecifics& specifics) {
   std::unique_ptr<EntityData> entity_data(new EntityData());
   *entity_data->specifics.mutable_device_info() = specifics;
   entity_data->non_unique_name = specifics.client_name();
   return entity_data;
 }
@@ skipping 43 matching lines @@
 void DeviceInfoService::OnReadAllData(Result result,
                                       std::unique_ptr<RecordList> record_list) {
   if (result != Result::SUCCESS) {
     ReportStartupErrorToSync("Initial load of data failed.");
     // TODO(skym, crbug.com/582460): Handle unrecoverable initialization
     // failure.
     return;
   }
 
   for (const Record& r : *record_list.get()) {
-    std::unique_ptr<DeviceInfoSpecifics> specifics(
-        base::WrapUnique(new DeviceInfoSpecifics()));
+    std::unique_ptr<DeviceInfoSpecifics> specifics =
+        base::MakeUnique<DeviceInfoSpecifics>();
     if (specifics->ParseFromString(r.value)) {
       all_data_[specifics->cache_guid()] = std::move(specifics);
     } else {
       ReportStartupErrorToSync("Failed to deserialize specifics.");
       // TODO(skym, crbug.com/582460): Handle unrecoverable initialization
       // failure.
     }
   }
 
   has_data_loaded_ = true;
@@ skipping 172 matching lines @@
 Time DeviceInfoService::GetLastUpdateTime(
     const DeviceInfoSpecifics& specifics) {
   if (specifics.has_last_updated_timestamp()) {
     return syncer::ProtoTimeToTime(specifics.last_updated_timestamp());
   } else {
     return Time();
   }
 }
 
 }  // namespace sync_driver_v2