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

remoting/test/protocol_perftest.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 <utility>
+
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
@@ skipping 110 matching lines @@
 
   // protocol::VideoStub interface.
   void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
                           const base::Closure& done) override {
     if (video_packet->data().empty()) {
       // Ignore keep-alive packets
       done.Run();
       return;
     }
 
-    last_video_packet_ = video_packet.Pass();
+    last_video_packet_ = std::move(video_packet);
 
     if (!on_frame_task_.is_null())
       on_frame_task_.Run();
 
     done.Run();
   }
 
   // HostStatusObserver interface.
   void OnClientConnected(const std::string& jid) override {
     message_loop_.PostTask(
@@ skipping 83 matching lines @@
     scoped_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     port_allocator_factory->socket_factory()->SetBandwidth(
         GetParam().bandwidth, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
-            host_signaling_.get(), port_allocator_factory.Pass(),
+            host_signaling_.get(), std::move(port_allocator_factory),
             network_settings, protocol::TransportRole::SERVER));
 
     scoped_ptr<protocol::SessionManager> session_manager(
         new protocol::JingleSessionManager(
             make_scoped_ptr(
                 new protocol::IceTransportFactory(transport_context)),
             host_signaling_.get()));
     session_manager->set_protocol_config(protocol_config_->Clone());
 
     // Encoder runs on a separate thread, main thread is used for everything
     // else.
-    host_.reset(new ChromotingHost(&desktop_environment_factory_,
-                                   session_manager.Pass(),
-                                   host_thread_.task_runner(),
-                                   host_thread_.task_runner(),
-                                   capture_thread_.task_runner(),
-                                   encode_thread_.task_runner(),
-                                   host_thread_.task_runner(),
-                                   host_thread_.task_runner()));
+    host_.reset(new ChromotingHost(
+        &desktop_environment_factory_, std::move(session_manager),
+        host_thread_.task_runner(), host_thread_.task_runner(),
+        capture_thread_.task_runner(), encode_thread_.task_runner(),
+        host_thread_.task_runner(), host_thread_.task_runner()));
 
     base::FilePath certs_dir(net::GetTestCertsDirectory());
 
     std::string host_cert;
     ASSERT_TRUE(base::ReadFileToString(
         certs_dir.AppendASCII("unittest.selfsigned.der"), &host_cert));
 
     base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
     std::string key_string;
     ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
     std::string key_base64;
     base::Base64Encode(key_string, &key_base64);
     scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(key_base64);
     ASSERT_TRUE(key_pair.get());
 
     protocol::SharedSecretHash host_secret;
     host_secret.hash_function = protocol::AuthenticationMethod::NONE;
     host_secret.value = "123456";
     scoped_ptr<protocol::AuthenticatorFactory> auth_factory =
         protocol::Me2MeHostAuthenticatorFactory::CreateWithSharedSecret(
             true, kHostOwner, host_cert, key_pair, host_secret, nullptr);
-    host_->SetAuthenticatorFactory(auth_factory.Pass());
+    host_->SetAuthenticatorFactory(std::move(auth_factory));
 
     host_->AddStatusObserver(this);
     host_->Start(kHostOwner);
 
     message_loop_.PostTask(FROM_HERE,
                            base::Bind(&ProtocolPerfTest::StartClientAfterHost,
                                       base::Unretained(this)));
   }
 
   void StartClientAfterHost() {
     client_signaling_->ConnectTo(host_signaling_.get());
 
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     // Initialize client.
     client_context_.reset(
         new ClientContext(base::ThreadTaskRunnerHandle::Get()));
 
     scoped_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     port_allocator_factory->socket_factory()->SetBandwidth(
         GetParam().bandwidth, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
-            host_signaling_.get(), port_allocator_factory.Pass(),
+            host_signaling_.get(), std::move(port_allocator_factory),
             network_settings, protocol::TransportRole::SERVER));
 
     std::vector<protocol::AuthenticationMethod> auth_methods;
     auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
         protocol::AuthenticationMethod::NONE));
     scoped_ptr<protocol::Authenticator> client_authenticator(
         new protocol::NegotiatingClientAuthenticator(
             std::string(),  // client_pairing_id
             std::string(),  // client_pairing_secret
             std::string(),  // authentication_tag
             base::Bind(&ProtocolPerfTest::FetchPin, base::Unretained(this)),
-            nullptr,
-            auth_methods));
+            nullptr, auth_methods));
     client_.reset(
         new ChromotingClient(client_context_.get(), this, this, nullptr));
     client_->set_protocol_config(protocol_config_->Clone());
-    client_->Start(client_signaling_.get(), client_authenticator.Pass(),
+    client_->Start(client_signaling_.get(), std::move(client_authenticator),
                    transport_context, kHostJid, std::string());
   }
 
   void FetchPin(
       bool pairing_supported,
       const protocol::SecretFetchedCallback& secret_fetched_callback) {
     secret_fetched_callback.Run("123456");
   }
 
   base::MessageLoopForIO message_loop_;
@@ skipping 103 matching lines @@
       fresh_frame = true;
     }
     ++frame_index_;
 
     scoped_ptr<webrtc::DesktopFrame> result(current_frame_->Share());
     result->mutable_updated_region()->Clear();
     if (fresh_frame) {
       result->mutable_updated_region()->AddRect(
           webrtc::DesktopRect::MakeXYWH(0, 0, kWidth, kHeight));
     }
-    return result.Pass();
+    return result;
   }
 
  private:
   ~IntermittentChangeFrameGenerator() {}
   friend class base::RefCountedThreadSafe<IntermittentChangeFrameGenerator>;
 
   int frame_index_;
   scoped_ptr<webrtc::SharedDesktopFrame> current_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(IntermittentChangeFrameGenerator);
@@ skipping 26 matching lines @@
               << "ms Encode: " << last_video_packet_->encode_time_ms()
               << "ms Capture: " << last_video_packet_->capture_time_ms()
               << "ms";
     sum += latency;
   }
 
   LOG(INFO) << "Average: " << (sum / kFrames).InMillisecondsF();
 }
 
 }  // namespace remoting