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

remoting/host/win/wts_session_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/wts_session_process_delegate.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/win/scoped_handle.h"
@@ skipping 62 matching lines @@
 
   // Drains the completion port queue to make sure that all job object
   // notifications have been received.
   void DrainJobNotifications();
 
   // Notified that the completion port queue has been drained.
   void DrainJobNotificationsCompleted();
 
   // Creates and initializes the job object that will sandbox the launched child
   // processes.
-  void InitializeJob(scoped_ptr<base::win::ScopedHandle> job);
+  void InitializeJob(ScopedHandle job);
 
   // Notified that the job object initialization is complete.
-  void InitializeJobCompleted(scoped_ptr<base::win::ScopedHandle> job);
+  void InitializeJobCompleted(ScopedHandle job);
 
   // Called when the number of processes running in the job reaches zero.
   void OnActiveProcessZero();
 
   void ReportFatalError();
   void ReportProcessLaunched(base::win::ScopedHandle worker_process);
 
   // The task runner all public methods of this class should be called on.
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
@@ skipping 42 matching lines @@
     scoped_ptr<base::CommandLine> target_command,
     bool launch_elevated,
     const std::string& channel_security)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       channel_security_(channel_security),
       event_handler_(nullptr),
       get_named_pipe_client_pid_(nullptr),
       launch_elevated_(launch_elevated),
       launch_pending_(false),
-      target_command_(target_command.Pass()) {
-}
+      target_command_(std::move(target_command)) {}
 
 bool WtsSessionProcessDelegate::Core::Initialize(uint32_t session_id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Windows XP does not support elevation.
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     launch_elevated_ = false;
 
   if (launch_elevated_) {
     // GetNamedPipeClientProcessId() is available starting from Vista.
@@ skipping 21 matching lines @@
         JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
     info.BasicLimitInformation.ActiveProcessLimit = 2;
     if (!SetInformationJobObject(job.Get(),
                                  JobObjectExtendedLimitInformation,
                                  &info,
                                  sizeof(info))) {
       PLOG(ERROR) << "Failed to set limits on the job object";
       return false;
     }
 
-    // ScopedHandle is not compatible with base::Passed, so we wrap it to
-    // a scoped pointer.
-    scoped_ptr<ScopedHandle> job_wrapper(new ScopedHandle());
-    *job_wrapper = job.Pass();
-
     // To receive job object notifications the job object is registered with
     // the completion port represented by |io_task_runner|. The registration has
     // to be done on the I/O thread because
     // MessageLoopForIO::RegisterJobObject() can only be called via
     // MessageLoopForIO::current().
     io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&Core::InitializeJob, this, base::Passed(&job_wrapper)));
+        FROM_HERE, base::Bind(&Core::InitializeJob, this, base::Passed(&job)));
   }
 
   // Create a session token for the launched process.
   return CreateSessionToken(session_id, &session_token_);
 }
 
 void WtsSessionProcessDelegate::Core::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   KillProcess();
@@ skipping 100 matching lines @@
 
     DWORD desired_access =
         SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
     ScopedHandle worker_process(OpenProcess(desired_access, false, pid));
     if (!worker_process.IsValid()) {
       PLOG(ERROR) << "Failed to open process " << pid;
       ReportFatalError();
       return;
     }
 
-    ReportProcessLaunched(worker_process.Pass());
+    ReportProcessLaunched(std::move(worker_process));
   }
 
   if (event_handler_)
     event_handler_->OnChannelConnected(peer_pid);
 }
 
 void WtsSessionProcessDelegate::Core::OnChannelError() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   event_handler_->OnChannelError();
@@ skipping 70 matching lines @@
       return;
     }
   }
 
   if (!ResumeThread(worker_thread.Get())) {
     PLOG(ERROR) << "Failed to resume the worker thread";
     ReportFatalError();
     return;
   }
 
-  channel_ = channel.Pass();
-  pipe_ = pipe.Pass();
+  channel_ = std::move(channel);
+  pipe_ = std::move(pipe);
 
   // Report success if the worker process is lauched directly. Otherwise, PID of
   // the client connected to the pipe will be used later. See
   // OnChannelConnected().
   if (!launch_elevated_)
-    ReportProcessLaunched(worker_process.Pass());
+    ReportProcessLaunched(std::move(worker_process));
 }
 
 void WtsSessionProcessDelegate::Core::DrainJobNotifications() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // DrainJobNotifications() is posted after the job object is destroyed, so
   // by this time all notifications from the job object have been processed
   // already. Let the main thread know that the queue has been drained.
   caller_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Core::DrainJobNotificationsCompleted, this));
 }
 
 void WtsSessionProcessDelegate::Core::DrainJobNotificationsCompleted() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (job_.IsValid()) {
     job_.Close();
 
     // Drain the completion queue to make sure all job object notification have
     // been received.
     io_task_runner_->PostTask(FROM_HERE, base::Bind(
         &Core::DrainJobNotifications, this));
   }
 }
 
-void WtsSessionProcessDelegate::Core::InitializeJob(
-    scoped_ptr<base::win::ScopedHandle> job) {
+void WtsSessionProcessDelegate::Core::InitializeJob(ScopedHandle job) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Register to receive job notifications via the I/O thread's completion port.
-  if (!base::MessageLoopForIO::current()->RegisterJobObject(job->Get(), this)) {
+  if (!base::MessageLoopForIO::current()->RegisterJobObject(job.Get(), this)) {
     PLOG(ERROR) << "Failed to associate the job object with a completion port";
     return;
   }
 
   // Let the main thread know that initialization is complete.
   caller_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Core::InitializeJobCompleted, this, base::Passed(&job)));
 }
 
-void WtsSessionProcessDelegate::Core::InitializeJobCompleted(
-    scoped_ptr<ScopedHandle> job) {
+void WtsSessionProcessDelegate::Core::InitializeJobCompleted(ScopedHandle job) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!job_.IsValid());
 
-  job_ = job->Pass();
+  job_ = std::move(job);
 
   if (launch_pending_)
     DoLaunchProcess();
 }
 
 void WtsSessionProcessDelegate::Core::OnActiveProcessZero() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (launch_pending_) {
     LOG(ERROR) << "The worker process exited before connecting via IPC.";
@@ skipping 11 matching lines @@
   WorkerProcessLauncher* event_handler = event_handler_;
   event_handler_ = nullptr;
   event_handler->OnFatalError();
 }
 
 void WtsSessionProcessDelegate::Core::ReportProcessLaunched(
     base::win::ScopedHandle worker_process) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   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));
 }
 
 WtsSessionProcessDelegate::WtsSessionProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_ptr<base::CommandLine> target_command,
     bool launch_elevated,
     const std::string& channel_security) {
-  core_ = new Core(io_task_runner,
-                   target_command.Pass(),
-                   launch_elevated,
+  core_ = new Core(io_task_runner, std::move(target_command), launch_elevated,
                    channel_security);
 }
 
 WtsSessionProcessDelegate::~WtsSessionProcessDelegate() {
   core_->Stop();
 }
 
 bool WtsSessionProcessDelegate::Initialize(uint32_t session_id) {
   return core_->Initialize(session_id);
 }
 
 void WtsSessionProcessDelegate::LaunchProcess(
     WorkerProcessLauncher* event_handler) {
   core_->LaunchProcess(event_handler);
 }
 
 void WtsSessionProcessDelegate::Send(IPC::Message* message) {
   core_->Send(message);
 }
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting