Convert //remoting to use std::unique_ptr

remoting/host/daemon_process_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/daemon_process.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/process/process.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
@@ skipping 52 matching lines @@
 
   // DaemonProcess overrides.
   void SendToNetwork(IPC::Message* message) override;
   bool OnDesktopSessionAgentAttached(
       int terminal_id,
       base::ProcessHandle desktop_process,
       IPC::PlatformFileForTransit desktop_pipe) override;
 
  protected:
   // DaemonProcess implementation.
-  scoped_ptr<DesktopSession> DoCreateDesktopSession(
+  std::unique_ptr<DesktopSession> DoCreateDesktopSession(
       int terminal_id,
       const ScreenResolution& resolution,
       bool virtual_terminal) override;
   void DoCrashNetworkProcess(
       const tracked_objects::Location& location) override;
   void LaunchNetworkProcess() override;
 
   // Changes the service start type to 'manual'.
   void DisableAutoStart();
 
   // Initializes the pairing registry on the host side by sending
   // ChromotingDaemonNetworkMsg_InitializePairingRegistry message.
   bool InitializePairingRegistry();
 
   // Opens the pairing registry keys.
   bool OpenPairingRegistry();
 
  private:
-  scoped_ptr<WorkerProcessLauncher> network_launcher_;
+  std::unique_ptr<WorkerProcessLauncher> network_launcher_;
 
   // Handle of the network process.
   ScopedHandle network_process_;
 
   base::win::RegKey pairing_registry_privileged_key_;
   base::win::RegKey pairing_registry_unprivileged_key_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonProcessWin);
 };
 
@@ skipping 64 matching lines @@
     return false;
   }
 
   // |desktop_pipe| is a handle in the desktop process. It will be duplicated
   // by the network process directly from the desktop process.
   SendToNetwork(new ChromotingDaemonNetworkMsg_DesktopAttached(
       terminal_id, desktop_process_for_transit, desktop_pipe));
   return true;
 }
 
-scoped_ptr<DesktopSession> DaemonProcessWin::DoCreateDesktopSession(
+std::unique_ptr<DesktopSession> DaemonProcessWin::DoCreateDesktopSession(
     int terminal_id,
     const ScreenResolution& resolution,
     bool virtual_terminal) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   if (virtual_terminal) {
     return DesktopSessionWin::CreateForVirtualTerminal(
         caller_task_runner(), io_task_runner(), this, terminal_id, resolution);
   } else {
     return DesktopSessionWin::CreateForConsole(
@@ skipping 12 matching lines @@
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
   DCHECK(!network_launcher_);
 
   // Construct the host binary name.
   base::FilePath host_binary;
   if (!GetInstalledBinaryPath(kHostBinaryName, &host_binary)) {
     Stop();
     return;
   }
 
-  scoped_ptr<base::CommandLine> target(new base::CommandLine(host_binary));
+  std::unique_ptr<base::CommandLine> target(new base::CommandLine(host_binary));
   target->AppendSwitchASCII(kProcessTypeSwitchName, kProcessTypeHost);
   target->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
                            kCopiedSwitchNames, arraysize(kCopiedSwitchNames));
 
-  scoped_ptr<UnprivilegedProcessDelegate> delegate(
+  std::unique_ptr<UnprivilegedProcessDelegate> delegate(
       new UnprivilegedProcessDelegate(io_task_runner(), std::move(target)));
   network_launcher_.reset(new WorkerProcessLauncher(std::move(delegate), this));
 }
 
-scoped_ptr<DaemonProcess> DaemonProcess::Create(
+std::unique_ptr<DaemonProcess> DaemonProcess::Create(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     const base::Closure& stopped_callback) {
-  scoped_ptr<DaemonProcessWin> daemon_process(
-      new DaemonProcessWin(caller_task_runner, io_task_runner,
-                           stopped_callback));
+  std::unique_ptr<DaemonProcessWin> daemon_process(new DaemonProcessWin(
+      caller_task_runner, io_task_runner, stopped_callback));
   daemon_process->Initialize();
   return std::move(daemon_process);
 }
 
 void DaemonProcessWin::DisableAutoStart() {
   ScopedScHandle scmanager(
       OpenSCManager(nullptr, SERVICES_ACTIVE_DATABASE,
                     SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
   if (!scmanager.IsValid()) {
     PLOG(INFO) << "Failed to connect to the service control manager";
@@ skipping 127 matching lines @@
                 << "\\" << kPairingRegistrySecretsKeyName;
     return false;
   }
 
   pairing_registry_privileged_key_.Set(privileged.Take());
   pairing_registry_unprivileged_key_.Set(unprivileged.Take());
   return true;
 }
 
 }  // namespace remoting