Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.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 "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_factory.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/signin/core/account_id/account_id.h"
 
 namespace chromeos {
 
 namespace {
@@ skipping 89 matching lines @@
 }
 
 // static
 void EasyUnlockKeyManager::DeviceDataToRemoteDeviceDictionary(
     const AccountId& account_id,
     const EasyUnlockDeviceKeyData& data,
     base::DictionaryValue* dict) {
   dict->SetString(kKeyBluetoothAddress, data.bluetooth_address);
   dict->SetInteger(kKeyBluetoothType, static_cast<int>(data.bluetooth_type));
   dict->SetString(kKeyPsk, data.psk);
-  scoped_ptr<base::DictionaryValue> permit_record(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> permit_record(
+      new base::DictionaryValue);
   dict->Set(kKeyPermitRecord, permit_record.release());
   dict->SetString(kKeyPermitId, data.public_key);
   dict->SetString(kKeyPermitData, data.public_key);
   dict->SetString(kKeyPermitType, kPermitTypeLicence);
   dict->SetString(kKeyPermitPermitId,
                   base::StringPrintf(kPermitPermitIdFormat,
                                      account_id.GetUserEmail().c_str()));
 }
 
 // static
@@ skipping 29 matching lines @@
   return true;
 }
 
 // static
 void EasyUnlockKeyManager::DeviceDataListToRemoteDeviceList(
     const AccountId& account_id,
     const EasyUnlockDeviceKeyDataList& data_list,
     base::ListValue* device_list) {
   device_list->Clear();
   for (size_t i = 0; i < data_list.size(); ++i) {
-    scoped_ptr<base::DictionaryValue> device_dict(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> device_dict(
+        new base::DictionaryValue);
     DeviceDataToRemoteDeviceDictionary(account_id, data_list[i],
                                        device_dict.get());
     device_list->Append(device_dict.release());
   }
 }
 
 // static
 bool EasyUnlockKeyManager::RemoteDeviceListToDeviceDataList(
     const base::ListValue& device_list,
     EasyUnlockDeviceKeyDataList* data_list) {
@@ skipping 19 matching lines @@
 // static
 std::string EasyUnlockKeyManager::GetKeyLabel(size_t key_index) {
   return base::StringPrintf("%s%zu", kKeyLabelPrefix, key_index);
 }
 
 void EasyUnlockKeyManager::RunNextOperation() {
   if (pending_write_operation_ || pending_read_operation_)
     return;
 
   if (!write_operation_queue_.empty()) {
-    pending_write_operation_ = make_scoped_ptr(write_operation_queue_.front());
+    pending_write_operation_ = base::WrapUnique(write_operation_queue_.front());
     write_operation_queue_.pop_front();
     pending_write_operation_->Start();
   } else if (!read_operation_queue_.empty()) {
-    pending_read_operation_ = make_scoped_ptr(read_operation_queue_.front());
+    pending_read_operation_ = base::WrapUnique(read_operation_queue_.front());
     read_operation_queue_.pop_front();
     pending_read_operation_->Start();
   }
 }
 
 void EasyUnlockKeyManager::OnKeysRefreshed(const RefreshKeysCallback& callback,
                                            bool refresh_success) {
   if (!callback.is_null())
     callback.Run(refresh_success);
 
   DCHECK(pending_write_operation_);
   pending_write_operation_.reset();
   RunNextOperation();
 }
 
 void EasyUnlockKeyManager::OnKeysFetched(
     const GetDeviceDataListCallback& callback,
     bool fetch_success,
     const EasyUnlockDeviceKeyDataList& fetched_data) {
   if (!callback.is_null())
     callback.Run(fetch_success, fetched_data);
 
   DCHECK(pending_read_operation_);
   pending_read_operation_.reset();
   RunNextOperation();
 }
 
 }  // namespace chromeos