Use std::move() instead of .Pass() in remoting/host

remoting/host/register_support_host_request.cc

 // Copyright (c) 2012 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/host/register_support_host_request.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 45 matching lines @@
     signal_strategy_->RemoveListener(this);
 }
 
 void RegisterSupportHostRequest::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
   if (state == SignalStrategy::CONNECTED) {
     DCHECK(!callback_.is_null());
 
     request_ = iq_sender_->SendIq(
         buzz::STR_SET, directory_bot_jid_,
-        CreateRegistrationRequest(signal_strategy_->GetLocalJid()).Pass(),
+        CreateRegistrationRequest(signal_strategy_->GetLocalJid()),
         base::Bind(&RegisterSupportHostRequest::ProcessResponse,
                    base::Unretained(this)));
   } else if (state == SignalStrategy::DISCONNECTED) {
     // We will reach here if signaling fails to connect.
     std::string error_message = "Signal strategy disconnected.";
     LOG(ERROR) << error_message;
     CallCallback(std::string(), base::TimeDelta(), error_message);
   }
 }
 
 bool RegisterSupportHostRequest::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   return false;
 }
 
 scoped_ptr<XmlElement> RegisterSupportHostRequest::CreateRegistrationRequest(
     const std::string& jid) {
   scoped_ptr<XmlElement> query(new XmlElement(
       QName(kChromotingXmlNamespace, kRegisterQueryTag)));
   XmlElement* public_key = new XmlElement(
       QName(kChromotingXmlNamespace, kPublicKeyTag));
   public_key->AddText(key_pair_->GetPublicKey());
   query->AddElement(public_key);
   query->AddElement(CreateSignature(jid).release());
-  return query.Pass();
+  return query;
 }
 
 scoped_ptr<XmlElement> RegisterSupportHostRequest::CreateSignature(
     const std::string& jid) {
   scoped_ptr<XmlElement> signature_tag(new XmlElement(
       QName(kChromotingXmlNamespace, kSignatureTag)));
 
   int64 time = static_cast<int64>(base::Time::Now().ToDoubleT());
   std::string time_str(base::Int64ToString(time));
   signature_tag->AddAttr(
       QName(kChromotingXmlNamespace, kSignatureTimeAttr), time_str);
 
   std::string message = NormalizeJid(jid) + ' ' + time_str;
   std::string signature(key_pair_->SignMessage(message));
   signature_tag->AddText(signature);
 
-  return signature_tag.Pass();
+  return signature_tag;
 }
 
 void RegisterSupportHostRequest::ParseResponse(const XmlElement* response,
                                                std::string* support_id,
                                                base::TimeDelta* lifetime,
                                                std::string* error_message) {
   std::ostringstream error;
 
   std::string type = response->Attr(buzz::QN_TYPE);
   if (type == buzz::STR_ERROR) {
@@ skipping 77 matching lines @@
   // Cleanup state before calling the callback.
   request_.reset();
   iq_sender_.reset();
   signal_strategy_->RemoveListener(this);
   signal_strategy_ = nullptr;
 
   base::ResetAndReturn(&callback_).Run(support_id, lifetime, error_message);
 }
 
 }  // namespace remoting