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

components/proximity_auth/cryptauth/cryptauth_device_manager.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/proximity_auth/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/base64url.h"
+#include "base/memory/ptr_util.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/proximity_auth/cryptauth/cryptauth_client.h"
 #include "components/proximity_auth/cryptauth/pref_names.h"
 #include "components/proximity_auth/cryptauth/sync_scheduler_impl.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace proximity_auth {
 
@@ skipping 10 matching lines @@
 // The bound on the amount to jitter the period between syncs.
 const double kDeviceSyncMaxJitterRatio = 0.2;
 
 // Keys for ExternalDeviceInfo dictionaries that are stored in the user's prefs.
 const char kExternalDeviceKeyPublicKey[] = "public_key";
 const char kExternalDeviceKeyDeviceName[] = "device_name";
 const char kExternalDeviceKeyBluetoothAddress[] = "bluetooth_address";
 
 // Converts an unlock key proto to a dictionary that can be stored in user
 // prefs.
-scoped_ptr<base::DictionaryValue> UnlockKeyToDictionary(
+std::unique_ptr<base::DictionaryValue> UnlockKeyToDictionary(
     const cryptauth::ExternalDeviceInfo& device) {
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
 
   // We store the device information in Base64Url form because dictionary values
   // must be valid UTF8 strings.
   std::string public_key_b64, device_name_b64, bluetooth_address_b64;
   base::Base64UrlEncode(device.public_key(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &public_key_b64);
   base::Base64UrlEncode(device.friendly_device_name(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &device_name_b64);
@@ skipping 40 matching lines @@
   external_device->set_friendly_device_name(device_name);
   external_device->set_bluetooth_address(bluetooth_address);
   external_device->set_unlock_key(true);
   external_device->set_unlockable(false);
   return true;
 }
 
 }  // namespace
 
 CryptAuthDeviceManager::CryptAuthDeviceManager(
-    scoped_ptr<base::Clock> clock,
-    scoped_ptr<CryptAuthClientFactory> client_factory,
+    std::unique_ptr<base::Clock> clock,
+    std::unique_ptr<CryptAuthClientFactory> client_factory,
     CryptAuthGCMManager* gcm_manager,
     PrefService* pref_service)
     : clock_(std::move(clock)),
       client_factory_(std::move(client_factory)),
       gcm_manager_(gcm_manager),
       pref_service_(pref_service),
       weak_ptr_factory_(this) {
   UpdateUnlockKeysFromPrefs();
 }
 
@@ skipping 61 matching lines @@
 }
 
 bool CryptAuthDeviceManager::IsRecoveringFromFailure() const {
   return scheduler_->GetStrategy() ==
          SyncScheduler::Strategy::AGGRESSIVE_RECOVERY;
 }
 
 void CryptAuthDeviceManager::OnGetMyDevicesSuccess(
     const cryptauth::GetMyDevicesResponse& response) {
   // Update the unlock keys stored in the user's prefs.
-  scoped_ptr<base::ListValue> unlock_keys_pref(new base::ListValue());
-  scoped_ptr<base::ListValue> devices_as_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> unlock_keys_pref(new base::ListValue());
+  std::unique_ptr<base::ListValue> devices_as_list(new base::ListValue());
   for (const auto& device : response.devices()) {
     devices_as_list->Append(UnlockKeyToDictionary(device));
     if (device.unlock_key())
       unlock_keys_pref->Append(UnlockKeyToDictionary(device));
   }
   PA_LOG(INFO) << "Devices Synced:\n" << *devices_as_list;
 
   bool unlock_keys_changed = !unlock_keys_pref->Equals(
       pref_service_->GetList(prefs::kCryptAuthDeviceSyncUnlockKeys));
   {
@@ skipping 25 matching lines @@
   pref_service_->SetBoolean(prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure,
                             true);
   sync_request_->OnDidComplete(false);
   cryptauth_client_.reset();
   sync_request_.reset();
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnSyncFinished(SyncResult::FAILURE, DeviceChangeResult::UNCHANGED));
 }
 
-scoped_ptr<SyncScheduler> CryptAuthDeviceManager::CreateSyncScheduler() {
-  return make_scoped_ptr(new SyncSchedulerImpl(
+std::unique_ptr<SyncScheduler> CryptAuthDeviceManager::CreateSyncScheduler() {
+  return base::WrapUnique(new SyncSchedulerImpl(
       this, base::TimeDelta::FromHours(kRefreshPeriodHours),
       base::TimeDelta::FromMinutes(kDeviceSyncBaseRecoveryPeriodMinutes),
       kDeviceSyncMaxJitterRatio, "CryptAuth DeviceSync"));
 }
 
 void CryptAuthDeviceManager::OnResyncMessage() {
   ForceSyncNow(cryptauth::INVOCATION_REASON_SERVER_INITIATED);
 }
 
 void CryptAuthDeviceManager::UpdateUnlockKeysFromPrefs() {
@@ skipping 11 matching lines @@
                       << "(index=" << i << "):\n" << *unlock_key_dictionary;
       }
     } else {
       PA_LOG(ERROR) << "Can not get dictionary in list of unlock keys "
                     << "(index=" << i << "):\n" << *unlock_key_list;
     }
   }
 }
 
 void CryptAuthDeviceManager::OnSyncRequested(
-    scoped_ptr<SyncScheduler::SyncRequest> sync_request) {
+    std::unique_ptr<SyncScheduler::SyncRequest> sync_request) {
   FOR_EACH_OBSERVER(Observer, observers_, OnSyncStarted());
 
   sync_request_ = std::move(sync_request);
   cryptauth_client_ = client_factory_->CreateInstance();
 
   cryptauth::InvocationReason invocation_reason =
       cryptauth::INVOCATION_REASON_UNKNOWN;
 
   int reason_stored_in_prefs =
       pref_service_->GetInteger(prefs::kCryptAuthDeviceSyncReason);
@@ skipping 20 matching lines @@
   request.set_invocation_reason(invocation_reason);
   request.set_allow_stale_read(is_sync_speculative);
   cryptauth_client_->GetMyDevices(
       request, base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesSuccess,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesFailure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace proximity_auth