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

remoting/signaling/xmpp_signal_strategy.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 "remoting/signaling/xmpp_signal_strategy.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 262 matching lines @@
 
   tls_state_ = TlsState::CONNECTING;
 
   // Reset the writer so we don't try to write to the raw socket anymore.
   writer_.reset();
 
   DCHECK(!read_pending_);
 
   scoped_ptr<net::ClientSocketHandle> socket_handle(
       new net::ClientSocketHandle());
-  socket_handle->SetSocket(socket_.Pass());
+  socket_handle->SetSocket(std::move(socket_));
 
   cert_verifier_ = net::CertVerifier::CreateDefault();
   transport_security_state_.reset(new net::TransportSecurityState());
   net::SSLClientSocketContext context;
   context.cert_verifier = cert_verifier_.get();
   context.transport_security_state = transport_security_state_.get();
 
   socket_ = socket_factory_->CreateSSLClientSocket(
-      socket_handle.Pass(),
+      std::move(socket_handle),
       net::HostPortPair(xmpp_server_config_.host, kDefaultHttpsPort),
       net::SSLConfig(), context);
 
   int result = socket_->Connect(
       base::Bind(&Core::OnTlsConnected, base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnTlsConnected(result);
 }
 
 void XmppSignalStrategy::Core::OnHandshakeDone(
     const std::string& jid,
     scoped_ptr<XmppStreamParser> parser) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   jid_ = jid;
-  stream_parser_ = parser.Pass();
+  stream_parser_ = std::move(parser);
   stream_parser_->SetCallbacks(
       base::Bind(&Core::OnStanza, base::Unretained(this)),
       base::Bind(&Core::OnParserError, base::Unretained(this)));
 
   // Don't need |login_handler_| anymore.
   login_handler_.reset();
 
   FOR_EACH_OBSERVER(Listener, listeners_,
                     OnSignalStrategyStateChange(CONNECTED));
 }
@@ skipping 191 matching lines @@
 }
 
 void XmppSignalStrategy::AddListener(Listener* listener) {
   core_->AddListener(listener);
 }
 
 void XmppSignalStrategy::RemoveListener(Listener* listener) {
   core_->RemoveListener(listener);
 }
 bool XmppSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
-  return core_->SendStanza(stanza.Pass());
+  return core_->SendStanza(std::move(stanza));
 }
 
 std::string XmppSignalStrategy::GetNextId() {
   return base::Uint64ToString(base::RandUint64());
 }
 
 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
                                      const std::string& auth_token) {
   core_->SetAuthInfo(username, auth_token);
 }
 
 }  // namespace remoting