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

remoting/protocol/jingle_session.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/protocol/jingle_session.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 78 matching lines @@
   return error_;
 }
 
 void JingleSession::StartConnection(const std::string& peer_jid,
                                     scoped_ptr<Authenticator> authenticator) {
   DCHECK(CalledOnValidThread());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::MESSAGE_READY);
 
   peer_jid_ = peer_jid;
-  authenticator_ = authenticator.Pass();
+  authenticator_ = std::move(authenticator);
 
   // Generate random session ID. There are usually not more than 1
   // concurrent session per host, so a random 64-bit integer provides
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Uint64ToString(
       base::RandGenerator(std::numeric_limits<uint64_t>::max()));
 
   transport_ = session_manager_->transport_factory_->CreateTransport();
 
@@ skipping 11 matching lines @@
 
 void JingleSession::InitializeIncomingConnection(
     const JingleMessage& initiate_message,
     scoped_ptr<Authenticator> authenticator) {
   DCHECK(CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
 
   peer_jid_ = initiate_message.from;
-  authenticator_ = authenticator.Pass();
+  authenticator_ = std::move(authenticator);
   session_id_ = initiate_message.sid;
 
   SetState(ACCEPTING);
 
   config_ =
       SessionConfig::SelectCommon(initiate_message.description->config(),
                                   session_manager_->protocol_config_.get());
   if (!config_) {
     LOG(WARNING) << "Rejecting connection from " << peer_jid_
                  << " because no compatible configuration has been found.";
@@ skipping 33 matching lines @@
 
   // Send the session-accept message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
   scoped_ptr<buzz::XmlElement> auth_message;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
     auth_message = authenticator_->GetNextMessage();
 
   message.description.reset(new ContentDescription(
-      CandidateSessionConfig::CreateFrom(*config_), auth_message.Pass()));
+      CandidateSessionConfig::CreateFrom(*config_), std::move(auth_message)));
   SendMessage(message);
 
   // Update state.
   SetState(ACCEPTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     OnAuthenticated();
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
     if (authenticator_->started()) {
@@ skipping 123 matching lines @@
       Close(PEER_IS_OFFLINE);
     }
   }
 }
 
 void JingleSession::OnOutgoingTransportInfo(
     scoped_ptr<XmlElement> transport_info) {
   DCHECK(CalledOnValidThread());
 
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
-  message.transport_info = transport_info.Pass();
+  message.transport_info = std::move(transport_info);
 
   scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
       message.ToXml(), base::Bind(&JingleSession::OnTransportInfoResponse,
                                   base::Unretained(this)));
   if (request) {
     request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
     transport_info_requests_.push_back(request.release());
   } else {
     LOG(ERROR) << "Failed to send a transport-info message";
   }
@@ skipping 262 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == ACCEPTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting