Convert //remoting to use std::unique_ptr

remoting/host/desktop_session_proxy.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_proxy.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/client_session_control.h"
@@ skipping 75 matching lines @@
       io_task_runner_(io_task_runner),
       client_session_control_(client_session_control),
       desktop_session_connector_(desktop_session_connector),
       pending_capture_frame_requests_(0),
       is_desktop_session_connected_(false),
       virtual_terminal_(virtual_terminal),
       supports_touch_events_(supports_touch_events) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
-scoped_ptr<AudioCapturer> DesktopSessionProxy::CreateAudioCapturer() {
+std::unique_ptr<AudioCapturer> DesktopSessionProxy::CreateAudioCapturer() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  return make_scoped_ptr(new IpcAudioCapturer(this));
+  return base::WrapUnique(new IpcAudioCapturer(this));
 }
 
-scoped_ptr<InputInjector> DesktopSessionProxy::CreateInputInjector() {
+std::unique_ptr<InputInjector> DesktopSessionProxy::CreateInputInjector() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  return make_scoped_ptr(new IpcInputInjector(this));
+  return base::WrapUnique(new IpcInputInjector(this));
 }
 
-scoped_ptr<ScreenControls> DesktopSessionProxy::CreateScreenControls() {
+std::unique_ptr<ScreenControls> DesktopSessionProxy::CreateScreenControls() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  return make_scoped_ptr(new IpcScreenControls(this));
+  return base::WrapUnique(new IpcScreenControls(this));
 }
 
-scoped_ptr<webrtc::DesktopCapturer> DesktopSessionProxy::CreateVideoCapturer() {
+std::unique_ptr<webrtc::DesktopCapturer>
+DesktopSessionProxy::CreateVideoCapturer() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  return make_scoped_ptr(new IpcVideoFrameCapturer(this));
+  return base::WrapUnique(new IpcVideoFrameCapturer(this));
 }
 
-scoped_ptr<webrtc::MouseCursorMonitor>
-    DesktopSessionProxy::CreateMouseCursorMonitor() {
-  return make_scoped_ptr(new IpcMouseCursorMonitor(this));
+std::unique_ptr<webrtc::MouseCursorMonitor>
+DesktopSessionProxy::CreateMouseCursorMonitor() {
+  return base::WrapUnique(new IpcMouseCursorMonitor(this));
 }
 
 std::string DesktopSessionProxy::GetCapabilities() const {
   std::string result = protocol::kRateLimitResizeRequests;
   // Ask the client to send its resolution unconditionally.
   if (virtual_terminal_)
     result = result + " " + protocol::kSendInitialResolution;
 
   if (supports_touch_events_)
     result = result + " "  + protocol::kTouchEventsCapability;
@@ skipping 218 matching lines @@
   if (!event.SerializeToString(&serialized_event)) {
     LOG(ERROR) << "Failed to serialize protocol::TouchEvent.";
     return;
   }
 
   SendToDesktop(
       new ChromotingNetworkDesktopMsg_InjectTouchEvent(serialized_event));
 }
 
 void DesktopSessionProxy::StartInputInjector(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+    std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   client_clipboard_ = std::move(client_clipboard);
 }
 
 void DesktopSessionProxy::SetScreenResolution(
     const ScreenResolution& resolution) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (resolution.IsEmpty())
@@ skipping 39 matching lines @@
     LOG(ERROR) << "Failed to find the shared buffer " << id;
     return nullptr;
   }
 }
 
 void DesktopSessionProxy::OnAudioPacket(const std::string& serialized_packet) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Parse a serialized audio packet. No further validation is done since
   // the message was sent by more privileged process.
-  scoped_ptr<AudioPacket> packet(new AudioPacket());
+  std::unique_ptr<AudioPacket> packet(new AudioPacket());
   if (!packet->ParseFromString(serialized_packet)) {
     LOG(ERROR) << "Failed to parse AudioPacket.";
     return;
   }
 
   // Pass a captured audio packet to |audio_capturer_|.
   audio_capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&IpcAudioCapturer::OnAudioPacket, audio_capturer_,
                             base::Passed(&packet)));
 }
@@ skipping 23 matching lines @@
 void DesktopSessionProxy::OnCaptureCompleted(
     const SerializedDesktopFrame& serialized_frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Assume that |serialized_frame| is well-formed because it was received from
   // a more privileged process.
   scoped_refptr<IpcSharedBufferCore> shared_buffer_core =
       GetSharedBufferCore(serialized_frame.shared_buffer_id);
   CHECK(shared_buffer_core.get());
 
-  scoped_ptr<webrtc::DesktopFrame> frame(
+  std::unique_ptr<webrtc::DesktopFrame> frame(
       new webrtc::SharedMemoryDesktopFrame(
           serialized_frame.dimensions, serialized_frame.bytes_per_row,
           new IpcSharedBuffer(shared_buffer_core)));
   frame->set_capture_time_ms(serialized_frame.capture_time_ms);
   frame->set_dpi(serialized_frame.dpi);
 
   for (size_t i = 0; i < serialized_frame.dirty_region.size(); ++i) {
     frame->mutable_updated_region()->AddRect(serialized_frame.dirty_region[i]);
   }
 
   --pending_capture_frame_requests_;
   video_capturer_->OnCaptureCompleted(std::move(frame));
 }
 
 void DesktopSessionProxy::OnMouseCursor(
     const webrtc::MouseCursor& mouse_cursor) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (mouse_cursor_monitor_) {
     mouse_cursor_monitor_->OnMouseCursor(
-        make_scoped_ptr(webrtc::MouseCursor::CopyOf(mouse_cursor)));
+        base::WrapUnique(webrtc::MouseCursor::CopyOf(mouse_cursor)));
   }
 }
 
 void DesktopSessionProxy::OnInjectClipboardEvent(
     const std::string& serialized_event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (client_clipboard_) {
     protocol::ClipboardEvent event;
     if (!event.ParseFromString(serialized_event)) {
@@ skipping 16 matching lines @@
 }
 
 // static
 void DesktopSessionProxyTraits::Destruct(
     const DesktopSessionProxy* desktop_session_proxy) {
   desktop_session_proxy->caller_task_runner_->DeleteSoon(FROM_HERE,
                                                          desktop_session_proxy);
 }
 
 }  // namespace remoting