Re-write many calls to WrapUnique() with MakeUnique()

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"
@@ skipping 101 matching lines @@
 class SharedMemoryFactoryImpl : public webrtc::SharedMemoryFactory {
  public:
   typedef base::Callback<void(std::unique_ptr<IPC::Message> message)>
       SendMessageCallback;
 
   SharedMemoryFactoryImpl(const SendMessageCallback& send_message_callback)
       : send_message_callback_(send_message_callback) {}
 
   std::unique_ptr<webrtc::SharedMemory> CreateSharedMemory(
       size_t size) override {
-    base::Closure release_buffer_callback =
-        base::Bind(send_message_callback_,
-                   base::Passed(base::WrapUnique(
-                       new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(
-                           next_shared_buffer_id_))));
+    base::Closure release_buffer_callback = base::Bind(
+        send_message_callback_,
+        base::Passed(
+            base::MakeUnique<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(
-          base::WrapUnique(new ChromotingDesktopNetworkMsg_CreateSharedBuffer(
-              buffer->id(), buffer->shared_memory()->handle(),
-              buffer->size())));
+          base::MakeUnique<ChromotingDesktopNetworkMsg_CreateSharedBuffer>(
+              buffer->id(), buffer->shared_memory()->handle(), buffer->size()));
     }
 
     return std::move(buffer);
   }
 
  private:
   int next_shared_buffer_id_ = 1;
   SendMessageCallback send_message_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryFactoryImpl);
@@ skipping 80 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(base::WrapUnique(
-      new ChromotingDesktopNetworkMsg_DisconnectSession(error)));
+  SendToNetwork(
+      base::MakeUnique<ChromotingDesktopNetworkMsg_DisconnectSession>(error));
 }
 
 void DesktopSessionAgent::OnLocalMouseMoved(
     const webrtc::DesktopVector& new_pos) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   remote_input_filter_->LocalMouseMoved(new_pos);
 }
 
 void DesktopSessionAgent::SetDisableInputs(bool disable_inputs) {
@@ skipping 79 matching lines @@
     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());
     }
   }
 
   last_frame_ = std::move(frame);
 
-  SendToNetwork(base::WrapUnique(
-      new ChromotingDesktopNetworkMsg_CaptureResult(result, serialized_frame)));
+  SendToNetwork(base::MakeUnique<ChromotingDesktopNetworkMsg_CaptureResult>(
+      result, serialized_frame));
 }
 
 void DesktopSessionAgent::OnMouseCursor(webrtc::MouseCursor* cursor) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   std::unique_ptr<webrtc::MouseCursor> owned_cursor(cursor);
 
-  SendToNetwork(base::WrapUnique(
-      new ChromotingDesktopNetworkMsg_MouseCursor(*owned_cursor)));
+  SendToNetwork(
+      base::MakeUnique<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(base::WrapUnique(
-      new ChromotingDesktopNetworkMsg_InjectClipboardEvent(serialized_event)));
+  SendToNetwork(
+      base::MakeUnique<ChromotingDesktopNetworkMsg_InjectClipboardEvent>(
+          serialized_event));
 }
 
 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(base::WrapUnique(
-      new ChromotingDesktopNetworkMsg_AudioPacket(serialized_packet)));
+  SendToNetwork(base::MakeUnique<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;
 
   // Create an IPC channel to communicate with the network process.
@@ skipping 179 matching lines @@
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 }  // namespace remoting