Use std::move() instead of scoped_ptr<>::Pass().

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 "base/base64.h"
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 61 matching lines @@
   return Pairing();
 }
 
 scoped_ptr<base::DictionaryValue> PairingRegistry::Pairing::ToValue() const {
   scoped_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.Pass();
+  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)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       delegate_task_runner_(delegate_task_runner),
-      delegate_(delegate.Pass()) {
+      delegate_(std::move(delegate)) {
   DCHECK(delegate_);
 }
 
 PairingRegistry::Pairing PairingRegistry::CreatePairing(
     const std::string& client_name) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   Pairing result = Pairing::Create(client_name);
   AddPairing(result);
   return result;
@@ skipping 126 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) {
-  callback.Run(pairings.Pass());
+  callback.Run(std::move(pairings));
   pending_requests_.pop();
   ServiceNextRequest();
 }
 
 void PairingRegistry::SanitizePairings(const GetAllPairingsCallback& callback,
                                        scoped_ptr<base::ListValue> pairings) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<base::ListValue> sanitized_pairings(new base::ListValue());
   for (size_t i = 0; i < pairings->GetSize(); ++i) {
@@ skipping 12 matching lines @@
 
     // Clear the shared secrect and append the pairing data to the list.
     Pairing sanitized_pairing(
         pairing.created_time(),
         pairing.client_name(),
         pairing.client_id(),
         "");
     sanitized_pairings->Append(sanitized_pairing.ToValue().release());
   }
 
-  callback.Run(sanitized_pairings.Pass());
+  callback.Run(std::move(sanitized_pairings));
 }
 
 void PairingRegistry::ServiceOrQueueRequest(const base::Closure& request) {
   bool servicing_request = !pending_requests_.empty();
   pending_requests_.push(request);
   if (!servicing_request) {
     ServiceNextRequest();
   }
 }
 
 void PairingRegistry::ServiceNextRequest() {
   if (pending_requests_.empty())
     return;
 
   PostTask(delegate_task_runner_, FROM_HERE, pending_requests_.front());
 }
 
 }  // namespace protocol
 }  // namespace remoting