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

remoting/host/win/unprivileged_process_delegate.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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/unprivileged_process_delegate.h"
 
 #include <sddl.h>
 
+#include <utility>
+
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/win/scoped_handle.h"
@@ skipping 207 matching lines @@
   handles.Swap(*handles_out);
   return true;
 }
 
 }  // namespace
 
 UnprivilegedProcessDelegate::UnprivilegedProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_ptr<base::CommandLine> target_command)
     : io_task_runner_(io_task_runner),
-      target_command_(target_command.Pass()),
-      event_handler_(nullptr) {
-}
+      target_command_(std::move(target_command)),
+      event_handler_(nullptr) {}
 
 UnprivilegedProcessDelegate::~UnprivilegedProcessDelegate() {
   DCHECK(CalledOnValidThread());
   DCHECK(!channel_);
   DCHECK(!worker_process_.IsValid());
 }
 
 void UnprivilegedProcessDelegate::LaunchProcess(
     WorkerProcessLauncher* event_handler) {
   DCHECK(CalledOnValidThread());
@@ skipping 56 matching lines @@
     // even on 64bit platforms.
     std::string pipe_handle = base::StringPrintf(
         "%d", reinterpret_cast<ULONG_PTR>(client.GetPlatformFile()));
 
     // Pass the IPC channel via the command line.
     base::CommandLine command_line(target_command_->argv());
     command_line.AppendSwitchASCII(kDaemonPipeSwitchName, pipe_handle);
 
     // Create our own window station and desktop accessible by |logon_sid|.
     WindowStationAndDesktop handles;
-    if (!CreateWindowStationAndDesktop(logon_sid.Pass(), &handles)) {
+    if (!CreateWindowStationAndDesktop(std::move(logon_sid), &handles)) {
       PLOG(ERROR) << "Failed to create a window station and desktop";
       ReportFatalError();
       return;
     }
 
     // Try to launch the worker process. The launched process inherits
     // the window station, desktop and pipe handles, created above.
     ScopedHandle worker_thread;
-    if (!LaunchProcessWithToken(command_line.GetProgram(),
-                                command_line.GetCommandLineString(),
-                                token.Get(),
-                                &process_attributes,
-                                &thread_attributes,
-                                true,
-                                0,
-                                nullptr,
-                                &worker_process,
-                                &worker_thread)) {
+    if (!LaunchProcessWithToken(
+            command_line.GetProgram(), command_line.GetCommandLineString(),
+            token.Get(), &process_attributes, &thread_attributes, true, 0,
+            nullptr, &worker_process, &worker_thread)) {
       ReportFatalError();
       return;
     }
   }
 
-  channel_ = server.Pass();
-  ReportProcessLaunched(worker_process.Pass());
+  channel_ = std::move(server);
+  ReportProcessLaunched(std::move(worker_process));
 }
 
 void UnprivilegedProcessDelegate::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
 
   if (channel_) {
     channel_->Send(message);
   } else {
     delete message;
   }
@@ skipping 53 matching lines @@
   WorkerProcessLauncher* event_handler = event_handler_;
   event_handler_ = nullptr;
   event_handler->OnFatalError();
 }
 
 void UnprivilegedProcessDelegate::ReportProcessLaunched(
     base::win::ScopedHandle worker_process) {
   DCHECK(CalledOnValidThread());
   DCHECK(!worker_process_.IsValid());
 
-  worker_process_ = worker_process.Pass();
+  worker_process_ = std::move(worker_process);
 
   // Report a handle that can be used to wait for the worker process completion,
   // query information about the process and duplicate handles.
   DWORD desired_access =
       SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
   HANDLE temp_handle;
-  if (!DuplicateHandle(GetCurrentProcess(),
-                       worker_process_.Get(),
-                       GetCurrentProcess(),
-                       &temp_handle,
-                       desired_access,
-                       FALSE,
+  if (!DuplicateHandle(GetCurrentProcess(), worker_process_.Get(),
+                       GetCurrentProcess(), &temp_handle, desired_access, FALSE,
                        0)) {
     PLOG(ERROR) << "Failed to duplicate a handle";
     ReportFatalError();
     return;
   }
   ScopedHandle limited_handle(temp_handle);
 
-  event_handler_->OnProcessLaunched(limited_handle.Pass());
+  event_handler_->OnProcessLaunched(std::move(limited_handle));
 }
 
 }  // namespace remoting