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

remoting/host/win/worker_process_launcher_unittest.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/host/win/worker_process_launcher.h"
+
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/ipc_util.h"
 #include "remoting/host/win/launch_process_with_token.h"
-#include "remoting/host/win/worker_process_launcher.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::ScopedHandle;
 using testing::_;
 using testing::AnyNumber;
 using testing::CreateFunctor;
 using testing::DoAll;
@@ skipping 276 matching lines @@
     channel_client_->Send(
         new ChromotingDesktopNetworkMsg_DisconnectSession(protocol::OK));
   }
 }
 
 void WorkerProcessLauncherTest::CrashWorker() {
   launcher_->Crash(FROM_HERE);
 }
 
 void WorkerProcessLauncherTest::StartWorker() {
-  launcher_.reset(new WorkerProcessLauncher(
-      launcher_delegate_.Pass(),
-      &server_listener_));
+  launcher_.reset(new WorkerProcessLauncher(std::move(launcher_delegate_),
+                                            &server_listener_));
 
   launcher_->SetKillProcessTimeoutForTest(base::TimeDelta::FromMilliseconds(0));
 }
 
 void WorkerProcessLauncherTest::StopWorker() {
   launcher_.reset();
   DisconnectClient();
   channel_name_.clear();
   channel_server_.reset();
   task_runner_ = nullptr;
@@ skipping 32 matching lines @@
   channel_name_ = IPC::Channel::GenerateUniqueRandomChannelID();
   ScopedHandle pipe;
   ASSERT_TRUE(CreateIpcChannel(channel_name_, kIpcSecurityDescriptor, &pipe));
 
   // Wrap the pipe into an IPC channel.
   channel_server_ = IPC::ChannelProxy::Create(
       IPC::ChannelHandle(pipe.Get()), IPC::Channel::MODE_SERVER, this,
       task_runner_);
 
   HANDLE temp_handle;
-  ASSERT_TRUE(DuplicateHandle(GetCurrentProcess(),
-                              worker_process_.Get(),
-                              GetCurrentProcess(),
-                              &temp_handle,
-                              0,
-                              FALSE,
+  ASSERT_TRUE(DuplicateHandle(GetCurrentProcess(), worker_process_.Get(),
+                              GetCurrentProcess(), &temp_handle, 0, FALSE,
                               DUPLICATE_SAME_ACCESS));
-  ScopedHandle copy(temp_handle);
-
-  event_handler_->OnProcessLaunched(copy.Pass());
+  event_handler_->OnProcessLaunched(ScopedHandle(temp_handle));
 }
 
 TEST_F(WorkerProcessLauncherTest, Start) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(1)
       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::LaunchProcess));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(0);
   EXPECT_CALL(server_listener_, OnPermanentError(_))
@@ skipping 134 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   message_loop_.Run();
 }
 
 }  // namespace remoting