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

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 30 matching lines @@
 namespace {
 
 // Name of command-line flag to disable use of I444 by default.
 const char kDisableI444SwitchName[] = "disable-i444";
 
 std::unique_ptr<AudioEncoder> CreateAudioEncoder(
     const protocol::SessionConfig& config) {
   const protocol::ChannelConfig& audio_config = config.audio_config();
 
   if (audio_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
-    return base::WrapUnique(new AudioEncoderVerbatim());
+    return base::MakeUnique<AudioEncoderVerbatim>();
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
-    return base::WrapUnique(new AudioEncoderOpus());
+    return base::MakeUnique<AudioEncoderOpus>();
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace
 
 ClientSession::ClientSession(
     EventHandler* event_handler,
@@ skipping 118 matching lines @@
     const protocol::Capabilities& capabilities) {
   DCHECK(CalledOnValidThread());
 
   // Ignore all the messages but the 1st one.
   if (client_capabilities_) {
     LOG(WARNING) << "protocol::Capabilities has been received already.";
     return;
   }
 
   // Compute the set of capabilities supported by both client and host.
-  client_capabilities_ = base::WrapUnique(new std::string());
+  client_capabilities_ = base::MakeUnique<std::string>();
   if (capabilities.has_capabilities())
     *client_capabilities_ = capabilities.capabilities();
   capabilities_ = IntersectCapabilities(*client_capabilities_,
                                         host_capabilities_);
   extension_manager_->OnNegotiatedCapabilities(
       connection_->client_stub(), capabilities_);
 
   VLOG(1) << "Client capabilities: " << *client_capabilities_;
 
   desktop_environment_->SetCapabilities(capabilities_);
@@ skipping 240 matching lines @@
 }
 
 ClientSessionControl* ClientSession::session_control() {
   DCHECK(CalledOnValidThread());
   return this;
 }
 
 std::unique_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
   DCHECK(CalledOnValidThread());
 
-  return base::WrapUnique(
-      new protocol::ClipboardThreadProxy(client_clipboard_factory_.GetWeakPtr(),
-                                         base::ThreadTaskRunnerHandle::Get()));
+  return base::MakeUnique<protocol::ClipboardThreadProxy>(
+      client_clipboard_factory_.GetWeakPtr(),
+      base::ThreadTaskRunnerHandle::Get());
 }
 
 void ClientSession::OnVideoSizeChanged(protocol::VideoStream* video_stream,
                                        const webrtc::DesktopSize& size,
                                        const webrtc::DesktopVector& dpi) {
   DCHECK(CalledOnValidThread());
 
   mouse_clamping_filter_.set_output_size(size);
 
   switch (connection_->session()->config().protocol()) {
@@ skipping 32 matching lines @@
   }
 }
 
 void ClientSession::OnVideoFrameSent(protocol::VideoStream* stream,
                                      uint32_t frame_id,
                                      int64_t input_event_timestamp) {
   // TODO(sergeyu): Send a message to the client to notify about the new frame.
 }
 
 }  // namespace remoting