Convert //remoting to use std::unique_ptr

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 <memory>
 #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/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "ipc/ipc_message_macros.h"
@@ skipping 68 matching lines @@
   ~ConsoleSession() override;
 
  protected:
   // DesktopSession overrides.
   void SetScreenResolution(const ScreenResolution& resolution) override;
 
   // DesktopSessionWin overrides.
   void InjectSas() override;
 
  private:
-  scoped_ptr<SasInjector> sas_injector_;
+  std::unique_ptr<SasInjector> sas_injector_;
 
   DISALLOW_COPY_AND_ASSIGN(ConsoleSession);
 };
 
 // DesktopSession implementation which attaches to virtual RDP console.
 // Receives IPC messages from the desktop process, running in the console
 // session, via |WorkerProcessIpcDelegate|, and monitors console session
 // attach/detach events via |WtsConsoleObserer|.
 class RdpSession : public DesktopSessionWin {
  public:
@@ skipping 240 matching lines @@
 
   base::WeakPtr<RdpSession> desktop_session = desktop_session_;
   desktop_session_.reset();
   desktop_session->OnRdpClosed();
   return S_OK;
 }
 
 } // namespace
 
 // static
-scoped_ptr<DesktopSession> DesktopSessionWin::CreateForConsole(
+std::unique_ptr<DesktopSession> DesktopSessionWin::CreateForConsole(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     const ScreenResolution& resolution) {
-  return make_scoped_ptr(new ConsoleSession(
-      caller_task_runner, io_task_runner, daemon_process, id,
-      HostService::GetInstance()));
+  return base::WrapUnique(new ConsoleSession(caller_task_runner, io_task_runner,
+                                             daemon_process, id,
+                                             HostService::GetInstance()));
 }
 
 // static
-scoped_ptr<DesktopSession> DesktopSessionWin::CreateForVirtualTerminal(
+std::unique_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()));
+  std::unique_ptr<RdpSession> session(
+      new RdpSession(caller_task_runner, io_task_runner, daemon_process, id,
+                     HostService::GetInstance()));
   if (!session->Initialize(resolution))
     return nullptr;
 
   return std::move(session);
 }
 
 DesktopSessionWin::DesktopSessionWin(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
@@ skipping 124 matching lines @@
     result = GetInstalledBinaryPath(kHostBinaryName, &desktop_binary);
   }
 
   if (!result) {
     TerminateSession();
     return;
   }
 
   session_attach_timer_.Stop();
 
-  scoped_ptr<base::CommandLine> target(new base::CommandLine(desktop_binary));
+  std::unique_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_, std::move(target), launch_elevated,
-      base::WideToUTF8(kDaemonIpcSecurityDescriptor)));
+  std::unique_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(std::move(delegate), this));
 }
 
 void DesktopSessionWin::OnSessionDetached() {
@@ skipping 43 matching lines @@
                                 exploded.hour,
                                 exploded.minute,
                                 exploded.second,
                                 exploded.millisecond,
                                 passed.c_str());
 
   last_timestamp_ = now;
 }
 
 }  // namespace remoting