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

remoting/protocol/ice_transport_channel.cc

 // Copyright 2015 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/ice_transport_channel.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 73 matching lines @@
 
   transport_context_->CreatePortAllocator(
       base::Bind(&IceTransportChannel::OnPortAllocatorCreated,
                  weak_factory_.GetWeakPtr()));
 }
 
 void IceTransportChannel::OnPortAllocatorCreated(
       scoped_ptr<cricket::PortAllocator> port_allocator){
   DCHECK(!channel_.get());
 
-  port_allocator_ = port_allocator.Pass();
+  port_allocator_ = std::move(port_allocator);
 
   // Create P2PTransportChannel, attach signal handlers and connect it.
   // TODO(sergeyu): Specify correct component ID for the channel.
   channel_.reset(new cricket::P2PTransportChannel(
       std::string(), 0, nullptr, port_allocator_.get()));
   std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
   channel_->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
   channel_->SetIceRole((transport_context_->role() == TransportRole::CLIENT)
                            ? cricket::ICEROLE_CONTROLLING
                            : cricket::ICEROLE_CONTROLLED);
@@ skipping 32 matching lines @@
       FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds),
       this, &IceTransportChannel::TryReconnect);
 }
 
 void IceTransportChannel::NotifyConnected() {
   // Create P2PDatagramSocket adapter for the P2PTransportChannel.
   scoped_ptr<TransportChannelSocketAdapter> socket(
       new TransportChannelSocketAdapter(channel_.get()));
   socket->SetOnDestroyedCallback(base::Bind(
       &IceTransportChannel::OnChannelDestroyed, base::Unretained(this)));
-  base::ResetAndReturn(&callback_).Run(socket.Pass());
+  base::ResetAndReturn(&callback_).Run(std::move(socket));
 }
 
 void IceTransportChannel::SetRemoteCredentials(const std::string& ufrag,
                                                const std::string& password) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_ice_username_fragment_ = ufrag;
   remote_ice_password_ = password;
 
   if (channel_)
@@ skipping 120 matching lines @@
 
   // Restart ICE by resetting ICE password.
   std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
   delegate_->OnTransportIceCredentials(this, ice_username_fragment_,
                                             ice_password);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password);
 }
 
 }  // namespace protocol
 }  // namespace remoting