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

remoting/host/win/launch_process_with_token.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/launch_process_with_token.h"
 
 #include <windows.h>
 #include <winternl.h>
 
 #include <limits>
@@ skipping 98 matching lines @@
     if (!WaitNamedPipe(pipe_name.c_str(), kPipeBusyWaitTimeoutMs)) {
       break;
     }
   }
 
   if (!pipe.IsValid()) {
     PLOG(ERROR) << "Failed to connect to '" << pipe_name << "'";
     return false;
   }
 
-  *pipe_out = pipe.Pass();
+  *pipe_out = std::move(pipe);
   return true;
 }
 
 // Copies the process token making it a primary impersonation token.
 // The returned handle will have |desired_access| rights.
 bool CopyProcessToken(DWORD desired_access, ScopedHandle* token_out) {
   HANDLE temp_handle;
   if (!OpenProcessToken(GetCurrentProcess(),
                         TOKEN_DUPLICATE | desired_access,
                         &temp_handle)) {
@@ skipping 34 matching lines @@
     return false;
   }
 
   // Enable the SE_TCB_NAME privilege.
   if (!AdjustTokenPrivileges(privileged_token.Get(), FALSE, &state, 0, nullptr,
                              0)) {
     PLOG(ERROR) << "Failed to enable SE_TCB_NAME privilege in a token";
     return false;
   }
 
-  *token_out = privileged_token.Pass();
+  *token_out = std::move(privileged_token);
   return true;
 }
 
 // Fills the process and thread handles in the passed |process_information|
 // structure and resume the process if the caller didn't want to suspend it.
 bool ProcessCreateProcessResponse(DWORD creation_flags,
                                   PROCESS_INFORMATION* process_information) {
   // The execution server does not return handles to the created process and
   // thread.
   if (!process_information->hProcess) {
@@ skipping 251 matching lines @@
     PLOG(ERROR) << "Failed to change session ID of a token";
 
     // Revert to the default token.
     CHECK(RevertToSelf());
     return false;
   }
 
   // Revert to the default token.
   CHECK(RevertToSelf());
 
-  *token_out = session_token.Pass();
+  *token_out = std::move(session_token);
   return true;
 }
 
 bool LaunchProcessWithToken(const base::FilePath& binary,
                             const base::CommandLine::StringType& command_line,
                             HANDLE user_token,
                             SECURITY_ATTRIBUTES* process_attributes,
                             SECURITY_ATTRIBUTES* thread_attributes,
                             bool inherit_handles,
                             DWORD creation_flags,
@@ skipping 58 matching lines @@
 
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
   CHECK(process_info.IsValid());
   process_out->Set(process_info.TakeProcessHandle());
   thread_out->Set(process_info.TakeThreadHandle());
   return true;
 }
 
 }  // namespace remoting