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

remoting/host/win/worker_process_launcher.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 <utility>
+
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "base/win/windows_version.h"
 #include "ipc/ipc_message.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 
@@ skipping 24 matching lines @@
 
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 const int kKillProcessTimeoutSeconds = 5;
 const int kLaunchResultTimeoutSeconds = 5;
 
 namespace remoting {
 
-WorkerProcessLauncher::Delegate::~Delegate() {
-}
+WorkerProcessLauncher::Delegate::~Delegate() {}
 
 WorkerProcessLauncher::WorkerProcessLauncher(
     scoped_ptr<WorkerProcessLauncher::Delegate> launcher_delegate,
     WorkerProcessIpcDelegate* ipc_handler)
     : ipc_handler_(ipc_handler),
-      launcher_delegate_(launcher_delegate.Pass()),
+      launcher_delegate_(std::move(launcher_delegate)),
       exit_code_(CONTROL_C_EXIT),
       ipc_enabled_(false),
       kill_process_timeout_(
           base::TimeDelta::FromSeconds(kKillProcessTimeoutSeconds)),
       launch_backoff_(&kDefaultBackoffPolicy) {
   DCHECK(ipc_handler_ != nullptr);
 
   LaunchWorker();
 }
 
@@ skipping 43 matching lines @@
   DCHECK(!launch_timer_.IsRunning());
   DCHECK(!process_watcher_.GetWatchedObject());
   DCHECK(!worker_process_.IsValid());
 
   if (!process_watcher_.StartWatchingOnce(worker_process.Get(), this)) {
     StopWorker();
     return;
   }
 
   ipc_enabled_ = true;
-  worker_process_ = worker_process.Pass();
+  worker_process_ = std::move(worker_process);
 }
 
 void WorkerProcessLauncher::OnFatalError() {
   DCHECK(CalledOnValidThread());
 
   StopWorker();
 }
 
 bool WorkerProcessLauncher::OnMessageReceived(
   const IPC::Message& message) {
@@ skipping 126 matching lines @@
     ipc_handler_->OnPermanentError(exit_code_);
     return;
   }
 
   // Schedule the next attempt to launch the worker process.
   launch_timer_.Start(FROM_HERE, launch_backoff_.GetTimeUntilRelease(), this,
                       &WorkerProcessLauncher::LaunchWorker);
 }
 
 } // namespace remoting