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

remoting/host/desktop_session_win.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/desktop_session_win.h"
 
 #include <sddl.h>
+
 #include <limits>
+#include <utility>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 343 matching lines @@
 
 } // namespace
 
 // static
 scoped_ptr<DesktopSession> DesktopSessionWin::CreateForConsole(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     const ScreenResolution& resolution) {
-  scoped_ptr<ConsoleSession> session(new ConsoleSession(
+  return make_scoped_ptr(new ConsoleSession(
       caller_task_runner, io_task_runner, daemon_process, id,
       HostService::GetInstance()));
-
-  return session.Pass();
 }
 
 // static
 scoped_ptr<DesktopSession> DesktopSessionWin::CreateForVirtualTerminal(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     const ScreenResolution& resolution) {
   scoped_ptr<RdpSession> session(new RdpSession(
       caller_task_runner, io_task_runner, daemon_process, id,
       HostService::GetInstance()));
   if (!session->Initialize(resolution))
     return nullptr;
 
-  return session.Pass();
+  return std::move(session);
 }
 
 DesktopSessionWin::DesktopSessionWin(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor)
     : DesktopSession(daemon_process, id),
       caller_task_runner_(caller_task_runner),
@@ skipping 127 matching lines @@
 
   session_attach_timer_.Stop();
 
   scoped_ptr<base::CommandLine> target(new base::CommandLine(desktop_binary));
   target->AppendSwitchASCII(kProcessTypeSwitchName, kProcessTypeDesktop);
   // Copy the command line switches enabling verbose logging.
   target->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
                            kCopiedSwitchNames, arraysize(kCopiedSwitchNames));
 
   // Create a delegate capable of launching a process in a different session.
-  scoped_ptr<WtsSessionProcessDelegate> delegate(
-      new WtsSessionProcessDelegate(io_task_runner_,
-                                    target.Pass(),
-                                    launch_elevated,
-                                    base::WideToUTF8(
-                                        kDaemonIpcSecurityDescriptor)));
+  scoped_ptr<WtsSessionProcessDelegate> delegate(new WtsSessionProcessDelegate(
+      io_task_runner_, std::move(target), launch_elevated,
+      base::WideToUTF8(kDaemonIpcSecurityDescriptor)));
   if (!delegate->Initialize(session_id)) {
     TerminateSession();
     return;
   }
 
   // Create a launcher for the desktop process, using the per-session delegate.
-  launcher_.reset(new WorkerProcessLauncher(delegate.Pass(), this));
+  launcher_.reset(new WorkerProcessLauncher(std::move(delegate), this));
 }
 
 void DesktopSessionWin::OnSessionDetached() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   launcher_.reset();
 
   if (monitoring_notifications_) {
     ReportElapsedTime("detached");
 
@@ skipping 36 matching lines @@
                                 exploded.hour,
                                 exploded.minute,
                                 exploded.second,
                                 exploded.millisecond,
                                 passed.c_str());
 
   last_timestamp_ = now;
 }
 
 }  // namespace remoting