Convert //remoting to use std::unique_ptr

remoting/protocol/pairing_registry.cc

 // Copyright 2013 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 "remoting/protocol/pairing_registry.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 61 matching lines @@
     std::string shared_secret;
     pairing.GetString(kSharedSecretKey, &shared_secret);
     base::Time created_time = base::Time::FromJsTime(created_time_value);
     return Pairing(created_time, client_name, client_id, shared_secret);
   }
 
   LOG(ERROR) << "Failed to load pairing information: unexpected format.";
   return Pairing();
 }
 
-scoped_ptr<base::DictionaryValue> PairingRegistry::Pairing::ToValue() const {
-  scoped_ptr<base::DictionaryValue> pairing(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue> PairingRegistry::Pairing::ToValue()
+    const {
+  std::unique_ptr<base::DictionaryValue> pairing(new base::DictionaryValue());
   pairing->SetDouble(kCreatedTimeKey, created_time().ToJsTime());
   pairing->SetString(kClientNameKey, client_name());
   pairing->SetString(kClientIdKey, client_id());
   if (!shared_secret().empty())
     pairing->SetString(kSharedSecretKey, shared_secret());
   return pairing;
 }
 
 bool PairingRegistry::Pairing::operator==(const Pairing& other) const {
   return created_time_ == other.created_time_ &&
          client_id_ == other.client_id_ &&
          client_name_ == other.client_name_ &&
          shared_secret_ == other.shared_secret_;
 }
 
 bool PairingRegistry::Pairing::is_valid() const {
   // |shared_secret_| is optional. It will be empty on Windows because the
   // privileged registry key can only be read in the elevated host process.
   return !client_id_.empty();
 }
 
 PairingRegistry::PairingRegistry(
     scoped_refptr<base::SingleThreadTaskRunner> delegate_task_runner,
-    scoped_ptr<Delegate> delegate)
+    std::unique_ptr<Delegate> delegate)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       delegate_task_runner_(delegate_task_runner),
       delegate_(std::move(delegate)) {
   DCHECK(delegate_);
 }
 
 PairingRegistry::Pairing PairingRegistry::CreatePairing(
     const std::string& client_name) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
@@ skipping 69 matching lines @@
       this, DoneCallback());
   base::Closure request = base::Bind(
       &PairingRegistry::DoSave, this, pairing, wrapped_callback);
   ServiceOrQueueRequest(request);
 }
 
 void PairingRegistry::DoLoadAll(
     const protocol::PairingRegistry::GetAllPairingsCallback& callback) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<base::ListValue> pairings = delegate_->LoadAll();
+  std::unique_ptr<base::ListValue> pairings = delegate_->LoadAll();
   PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback,
                                                       base::Passed(&pairings)));
 }
 
 void PairingRegistry::DoDeleteAll(
     const protocol::PairingRegistry::DoneCallback& callback) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   bool success = delegate_->DeleteAll();
   PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback, success));
@@ skipping 38 matching lines @@
 
 void PairingRegistry::InvokeGetPairingCallbackAndScheduleNext(
     const GetPairingCallback& callback, Pairing pairing) {
   callback.Run(pairing);
   pending_requests_.pop();
   ServiceNextRequest();
 }
 
 void PairingRegistry::InvokeGetAllPairingsCallbackAndScheduleNext(
     const GetAllPairingsCallback& callback,
-    scoped_ptr<base::ListValue> pairings) {
+    std::unique_ptr<base::ListValue> pairings) {
   callback.Run(std::move(pairings));
   pending_requests_.pop();
   ServiceNextRequest();
 }
 
-void PairingRegistry::SanitizePairings(const GetAllPairingsCallback& callback,
-                                       scoped_ptr<base::ListValue> pairings) {
+void PairingRegistry::SanitizePairings(
+    const GetAllPairingsCallback& callback,
+    std::unique_ptr<base::ListValue> pairings) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<base::ListValue> sanitized_pairings(new base::ListValue());
+  std::unique_ptr<base::ListValue> sanitized_pairings(new base::ListValue());
   for (size_t i = 0; i < pairings->GetSize(); ++i) {
     base::DictionaryValue* pairing_json;
     if (!pairings->GetDictionary(i, &pairing_json)) {
       LOG(WARNING) << "A pairing entry is not a dictionary.";
       continue;
     }
 
     // Parse the pairing data.
     Pairing pairing = Pairing::CreateFromValue(*pairing_json);
     if (!pairing.is_valid()) {
@@ skipping 23 matching lines @@
 
 void PairingRegistry::ServiceNextRequest() {
   if (pending_requests_.empty())
     return;
 
   PostTask(delegate_task_runner_, FROM_HERE, pending_requests_.front());
 }
 
 }  // namespace protocol
 }  // namespace remoting