Convert //remoting to use std::unique_ptr

remoting/host/desktop_session_agent.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_agent.h"
 
 #include <utility>
 
 #include "base/files/file_util.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 "build/build_config.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
@@ skipping 41 matching lines @@
 DesktopSessionClipboardStub::~DesktopSessionClipboardStub() {}
 
 void DesktopSessionClipboardStub::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   desktop_session_agent_->InjectClipboardEvent(event);
 }
 
 // webrtc::SharedMemory implementation that creates base::SharedMemory.
 class SharedMemoryImpl : public webrtc::SharedMemory {
  public:
-  static scoped_ptr<SharedMemoryImpl>
+  static std::unique_ptr<SharedMemoryImpl>
   Create(size_t size, int id, const base::Closure& on_deleted_callback) {
-    scoped_ptr<base::SharedMemory> memory(new base::SharedMemory());
+    std::unique_ptr<base::SharedMemory> memory(new base::SharedMemory());
     if (!memory->CreateAndMapAnonymous(size))
       return nullptr;
-    return make_scoped_ptr(
+    return base::WrapUnique(
         new SharedMemoryImpl(std::move(memory), size, id, on_deleted_callback));
   }
 
   ~SharedMemoryImpl() override { on_deleted_callback_.Run(); }
 
   base::SharedMemory* shared_memory() { return shared_memory_.get(); }
 
  private:
-  SharedMemoryImpl(scoped_ptr<base::SharedMemory> memory,
+  SharedMemoryImpl(std::unique_ptr<base::SharedMemory> memory,
                    size_t size,
                    int id,
                    const base::Closure& on_deleted_callback)
       : SharedMemory(memory->memory(),
                      size,
 // webrtc::ScreenCapturer uses webrtc::SharedMemory::handle() only on Windows.
 #if defined(OS_WIN)
                      memory->handle().GetHandle(),
 #else
                      0,
 #endif
                      id),
         on_deleted_callback_(on_deleted_callback),
         shared_memory_(std::move(memory)) {
   }
 
   base::Closure on_deleted_callback_;
-  scoped_ptr<base::SharedMemory> shared_memory_;
+  std::unique_ptr<base::SharedMemory> shared_memory_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryImpl);
 };
 
 class SharedMemoryFactoryImpl : public webrtc::SharedMemoryFactory {
  public:
-  typedef base::Callback<void(scoped_ptr<IPC::Message> message)>
+  typedef base::Callback<void(std::unique_ptr<IPC::Message> message)>
       SendMessageCallback;
 
   SharedMemoryFactoryImpl(const SendMessageCallback& send_message_callback)
       : send_message_callback_(send_message_callback) {}
 
   rtc::scoped_ptr<webrtc::SharedMemory> CreateSharedMemory(
       size_t size) override {
-    base::Closure release_buffer_callback = base::Bind(
-        send_message_callback_,
-        base::Passed(
-            make_scoped_ptr(new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(
-                next_shared_buffer_id_))));
-    scoped_ptr<SharedMemoryImpl> buffer = SharedMemoryImpl::Create(
+    base::Closure release_buffer_callback =
+        base::Bind(send_message_callback_,
+                   base::Passed(base::WrapUnique(
+                       new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(
+                           next_shared_buffer_id_))));
+    std::unique_ptr<SharedMemoryImpl> buffer = SharedMemoryImpl::Create(
         size, next_shared_buffer_id_, release_buffer_callback);
     if (buffer) {
       // |next_shared_buffer_id_| starts from 1 and incrementing it by 2 makes
       // sure it is always odd and therefore zero is never used as a valid
       // buffer ID.
       //
       // It is very unlikely (though theoretically possible) to allocate the
       // same ID for two different buffers due to integer overflow. It should
       // take about a year of allocating 100 new buffers every second.
       // Practically speaking it never happens.
       next_shared_buffer_id_ += 2;
 
       send_message_callback_.Run(
-          make_scoped_ptr(new ChromotingDesktopNetworkMsg_CreateSharedBuffer(
+          base::WrapUnique(new ChromotingDesktopNetworkMsg_CreateSharedBuffer(
               buffer->id(), buffer->shared_memory()->handle(),
               buffer->size())));
     }
 
     return rtc_make_scoped_ptr(buffer.release());
   }
 
  private:
   int next_shared_buffer_id_ = 1;
   SendMessageCallback send_message_callback_;
@@ skipping 78 matching lines @@
   DCHECK(!network_channel_);
   DCHECK(!screen_controls_);
   DCHECK(!video_capturer_);
 }
 
 const std::string& DesktopSessionAgent::client_jid() const {
   return client_jid_;
 }
 
 void DesktopSessionAgent::DisconnectSession(protocol::ErrorCode error) {
-  SendToNetwork(make_scoped_ptr(
+  SendToNetwork(base::WrapUnique(
       new ChromotingDesktopNetworkMsg_DisconnectSession(error)));
 }
 
 void DesktopSessionAgent::OnLocalMouseMoved(
     const webrtc::DesktopVector& new_pos) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   remote_input_filter_->LocalMouseMoved(new_pos);
 }
 
@@ skipping 38 matching lines @@
   input_tracker_.reset(new protocol::InputEventTracker(input_injector_.get()));
   remote_input_filter_.reset(new RemoteInputFilter(input_tracker_.get()));
 
 #if defined(OS_WIN)
   // LocalInputMonitorWin filters out an echo of the injected input before it
   // reaches |remote_input_filter_|.
   remote_input_filter_->SetExpectLocalEcho(false);
 #endif  // defined(OS_WIN)
 
   // Start the input injector.
-  scoped_ptr<protocol::ClipboardStub> clipboard_stub(
+  std::unique_ptr<protocol::ClipboardStub> clipboard_stub(
       new DesktopSessionClipboardStub(this));
   input_injector_->Start(std::move(clipboard_stub));
 
   // Start the audio capturer.
   if (delegate_->desktop_environment_factory().SupportsAudioCapture()) {
     audio_capturer_ = desktop_environment_->CreateAudioCapturer();
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
   }
 
@@ skipping 19 matching lines @@
   serialized_frame.shared_buffer_id = frame->shared_memory()->id();
   serialized_frame.bytes_per_row = frame->stride();
   serialized_frame.dimensions = frame->size();
   serialized_frame.capture_time_ms = frame->capture_time_ms();
   serialized_frame.dpi = frame->dpi();
   for (webrtc::DesktopRegion::Iterator i(frame->updated_region());
        !i.IsAtEnd(); i.Advance()) {
     serialized_frame.dirty_region.push_back(i.rect());
   }
 
-  SendToNetwork(make_scoped_ptr(
+  SendToNetwork(base::WrapUnique(
       new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_frame)));
 }
 
 void DesktopSessionAgent::OnMouseCursor(webrtc::MouseCursor* cursor) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<webrtc::MouseCursor> owned_cursor(cursor);
+  std::unique_ptr<webrtc::MouseCursor> owned_cursor(cursor);
 
-  SendToNetwork(make_scoped_ptr(
+  SendToNetwork(base::WrapUnique(
       new ChromotingDesktopNetworkMsg_MouseCursor(*owned_cursor)));
 }
 
 void DesktopSessionAgent::OnMouseCursorPosition(
     webrtc::MouseCursorMonitor::CursorState state,
     const webrtc::DesktopVector& position) {
   // We're not subscribing to mouse position changes.
   NOTREACHED();
 }
 
 void DesktopSessionAgent::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   std::string serialized_event;
   if (!event.SerializeToString(&serialized_event)) {
     LOG(ERROR) << "Failed to serialize protocol::ClipboardEvent.";
     return;
   }
 
-  SendToNetwork(make_scoped_ptr(
+  SendToNetwork(base::WrapUnique(
       new ChromotingDesktopNetworkMsg_InjectClipboardEvent(serialized_event)));
 }
 
-void DesktopSessionAgent::ProcessAudioPacket(scoped_ptr<AudioPacket> packet) {
+void DesktopSessionAgent::ProcessAudioPacket(
+    std::unique_ptr<AudioPacket> packet) {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   std::string serialized_packet;
   if (!packet->SerializeToString(&serialized_packet)) {
     LOG(ERROR) << "Failed to serialize AudioPacket.";
     return;
   }
 
-  SendToNetwork(make_scoped_ptr(
+  SendToNetwork(base::WrapUnique(
       new ChromotingDesktopNetworkMsg_AudioPacket(serialized_packet)));
 }
 
 bool DesktopSessionAgent::Start(const base::WeakPtr<Delegate>& delegate,
                                 IPC::PlatformFileForTransit* desktop_pipe_out) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate_.get() == nullptr);
 
   delegate_ = delegate;
 
@@ skipping 147 matching lines @@
 }
 
 void DesktopSessionAgent::SetScreenResolution(
     const ScreenResolution& resolution) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (screen_controls_ && resolution.IsEmpty())
     screen_controls_->SetScreenResolution(resolution);
 }
 
-void DesktopSessionAgent::SendToNetwork(scoped_ptr<IPC::Message> message) {
+void DesktopSessionAgent::SendToNetwork(std::unique_ptr<IPC::Message> message) {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::SendToNetwork, this,
                               base::Passed(&message)));
     return;
   }
 
   if (network_channel_) {
     network_channel_->Send(message.release());
   }
 }
 
 void DesktopSessionAgent::StartAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   if (audio_capturer_) {
     audio_capturer_->Start(base::Bind(&DesktopSessionAgent::ProcessAudioPacket,
                                       this));
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 }  // namespace remoting