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

remoting/test/test_chromoting_client.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/test/test_chromoting_client.h"
 
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/chromoting_client.h"
@@ skipping 47 matching lines @@
 namespace remoting {
 namespace test {
 
 TestChromotingClient::TestChromotingClient()
     : TestChromotingClient(nullptr) {}
 
 TestChromotingClient::TestChromotingClient(
     scoped_ptr<VideoRenderer> video_renderer)
     : connection_to_host_state_(protocol::ConnectionToHost::INITIALIZING),
       connection_error_code_(protocol::OK),
-      video_renderer_(video_renderer.Pass()) {}
+      video_renderer_(std::move(video_renderer)) {}
 
 TestChromotingClient::~TestChromotingClient() {
   // Ensure any connections are closed and the members are destroyed in the
   // appropriate order.
   EndConnection();
 }
 
 void TestChromotingClient::StartConnection(
     const ConnectionSetupInfo& connection_setup_info) {
   // Required to establish a connection to the host.
@@ skipping 11 matching lines @@
     video_renderer_.reset(new TestVideoRenderer());
   }
 
   chromoting_client_.reset(new ChromotingClient(client_context_.get(),
                                                 this,  // client_user_interface.
                                                 video_renderer_.get(),
                                                 nullptr));  // audio_player
 
   if (test_connection_to_host_) {
     chromoting_client_->SetConnectionToHostForTests(
-        test_connection_to_host_.Pass());
+        std::move(test_connection_to_host_));
   }
 
   if (!signal_strategy_) {
     XmppSignalStrategy::XmppServerConfig xmpp_server_config;
     xmpp_server_config.host = kXmppHostName;
     xmpp_server_config.port = kXmppPortNumber;
     xmpp_server_config.use_tls = true;
     xmpp_server_config.username = connection_setup_info.user_name;
     xmpp_server_config.auth_token = connection_setup_info.access_token;
 
     // Set up the signal strategy.  This must outlive the client object.
     signal_strategy_.reset(
         new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
                                request_context_getter, xmpp_server_config));
   }
 
   protocol::NetworkSettings network_settings(
       protocol::NetworkSettings::NAT_TRAVERSAL_FULL);
 
   scoped_ptr<protocol::ChromiumPortAllocatorFactory> port_allocator_factory(
       new protocol::ChromiumPortAllocatorFactory(request_context_getter));
 
   scoped_refptr<protocol::TransportContext> transport_context(
       new protocol::TransportContext(
-          signal_strategy_.get(), port_allocator_factory.Pass(),
+          signal_strategy_.get(), std::move(port_allocator_factory),
           network_settings, protocol::TransportRole::CLIENT));
 
   scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
       token_fetcher(new TokenFetcherProxy(
           base::Bind(&FetchThirdPartyToken,
                      connection_setup_info.authorization_code,
                      connection_setup_info.shared_secret),
           connection_setup_info.public_key));
 
   protocol::FetchSecretCallback fetch_secret_callback;
   if (!connection_setup_info.pin.empty()) {
     fetch_secret_callback = base::Bind(&FetchSecret, connection_setup_info.pin);
   }
 
   scoped_ptr<protocol::Authenticator> authenticator(
       new protocol::NegotiatingClientAuthenticator(
-          connection_setup_info.pairing_id,
-          connection_setup_info.shared_secret,
-          connection_setup_info.host_id,
-          fetch_secret_callback,
-          token_fetcher.Pass(),
-          connection_setup_info.auth_methods));
+          connection_setup_info.pairing_id, connection_setup_info.shared_secret,
+          connection_setup_info.host_id, fetch_secret_callback,
+          std::move(token_fetcher), connection_setup_info.auth_methods));
 
   chromoting_client_->Start(
-      signal_strategy_.get(), authenticator.Pass(), transport_context,
+      signal_strategy_.get(), std::move(authenticator), transport_context,
       connection_setup_info.host_jid, connection_setup_info.capabilities);
 }
 
 void TestChromotingClient::EndConnection() {
   // Clearing out the client will close the connection.
   chromoting_client_.reset();
 
   // The signal strategy object must outlive the client so destroy it next.
   signal_strategy_.reset();
 
@@ skipping 16 matching lines @@
 
 void TestChromotingClient::RemoveRemoteConnectionObserver(
     RemoteConnectionObserver* observer) {
   DCHECK(observer);
 
   connection_observers_.RemoveObserver(observer);
 }
 
 void TestChromotingClient::SetSignalStrategyForTests(
     scoped_ptr<SignalStrategy> signal_strategy) {
-  signal_strategy_ = signal_strategy.Pass();
+  signal_strategy_ = std::move(signal_strategy);
 }
 
 void TestChromotingClient::SetConnectionToHostForTests(
     scoped_ptr<protocol::ConnectionToHost> connection_to_host) {
-  test_connection_to_host_ = connection_to_host.Pass();
+  test_connection_to_host_ = std::move(connection_to_host);
 }
 
 void TestChromotingClient::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error_code) {
   VLOG(1) << "TestChromotingClient::OnConnectionState("
           << "state: " << protocol::ConnectionToHost::StateToString(state)
           << ", error_code: " << protocol::ErrorCodeToString(error_code)
           << ") Called";
 
@@ skipping 68 matching lines @@
   VLOG(1) << "TestChromotingClient::InjectClipboardEvent() Called";
 }
 
 void TestChromotingClient::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   VLOG(1) << "TestChromotingClient::SetCursorShape() Called";
 }
 
 }  // namespace test
 }  // namespace remoting