Convert //remoting to use std::unique_ptr

remoting/host/desktop_session_proxy.h

 // 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.
 
 #ifndef REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
 #define REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory_handle.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_platform_file.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/proto/event.pb.h"
@@ skipping 50 matching lines @@
   DesktopSessionProxy(
       scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       base::WeakPtr<ClientSessionControl> client_session_control,
       base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
       bool virtual_terminal,
       bool supports_touch_events);
 
   // Mirrors DesktopEnvironment.
-  scoped_ptr<AudioCapturer> CreateAudioCapturer();
-  scoped_ptr<InputInjector> CreateInputInjector();
-  scoped_ptr<ScreenControls> CreateScreenControls();
-  scoped_ptr<webrtc::DesktopCapturer> CreateVideoCapturer();
-  scoped_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor();
+  std::unique_ptr<AudioCapturer> CreateAudioCapturer();
+  std::unique_ptr<InputInjector> CreateInputInjector();
+  std::unique_ptr<ScreenControls> CreateScreenControls();
+  std::unique_ptr<webrtc::DesktopCapturer> CreateVideoCapturer();
+  std::unique_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor();
   std::string GetCapabilities() const;
   void SetCapabilities(const std::string& capabilities);
 
   // IPC::Listener implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
 
   // Connects to the desktop session agent.
   bool AttachToDesktop(base::Process desktop_process,
@@ skipping 23 matching lines @@
   // Called on the |video_capture_task_runner_| thread.
   void SetMouseCursorMonitor(
       const base::WeakPtr<IpcMouseCursorMonitor>& mouse_cursor_monitor);
 
   // APIs used to implement the InputInjector interface.
   void InjectClipboardEvent(const protocol::ClipboardEvent& event);
   void InjectKeyEvent(const protocol::KeyEvent& event);
   void InjectTextEvent(const protocol::TextEvent& event);
   void InjectMouseEvent(const protocol::MouseEvent& event);
   void InjectTouchEvent(const protocol::TouchEvent& event);
-  void StartInputInjector(scoped_ptr<protocol::ClipboardStub> client_clipboard);
+  void StartInputInjector(
+      std::unique_ptr<protocol::ClipboardStub> client_clipboard);
 
   // API used to implement the SessionController interface.
   void SetScreenResolution(const ScreenResolution& resolution);
 
  private:
   friend class base::DeleteHelper<DesktopSessionProxy>;
   friend struct DesktopSessionProxyTraits;
 
   class IpcSharedBufferCore;
   class IpcSharedBuffer;
@@ skipping 34 matching lines @@
   //     |caller_task_runner_|.
   //   - background I/O is served on |io_task_runner_|.
   scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // Points to the audio capturer receiving captured audio packets.
   base::WeakPtr<IpcAudioCapturer> audio_capturer_;
 
   // Points to the client stub passed to StartInputInjector().
-  scoped_ptr<protocol::ClipboardStub> client_clipboard_;
+  std::unique_ptr<protocol::ClipboardStub> client_clipboard_;
 
   // Used to disconnect the client session.
   base::WeakPtr<ClientSessionControl> client_session_control_;
 
   // Used to create a desktop session and receive notifications every time
   // the desktop process is replaced.
   base::WeakPtr<DesktopSessionConnector> desktop_session_connector_;
 
   // Points to the video capturer receiving captured video frames.
   base::WeakPtr<IpcVideoFrameCapturer> video_capturer_;
 
   // Points to the mouse cursor monitor receiving mouse cursor changes.
   base::WeakPtr<IpcMouseCursorMonitor> mouse_cursor_monitor_;
 
   // IPC channel to the desktop session agent.
-  scoped_ptr<IPC::ChannelProxy> desktop_channel_;
+  std::unique_ptr<IPC::ChannelProxy> desktop_channel_;
 
   // Handle of the desktop process.
   base::Process desktop_process_;
 
   int pending_capture_frame_requests_;
 
   // Shared memory buffers by Id. Each buffer is owned by the corresponding
   // frame.
   SharedBuffers shared_buffers_;
 
@@ skipping 13 matching lines @@
 };
 
 // Destroys |DesktopSessionProxy| instances on the caller's thread.
 struct DesktopSessionProxyTraits {
   static void Destruct(const DesktopSessionProxy* desktop_session_proxy);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_DESKTOP_SESSION_PROXY_H_