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

remoting/protocol/ssl_hmac_channel_authenticator.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/protocol/ssl_hmac_channel_authenticator.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 254 matching lines @@
     }
 
     net::SSLServerConfig ssl_config;
     ssl_config.require_ecdhe = true;
 
     server_context_ = net::CreateSSLServerContext(
         cert.get(), *local_key_pair_->private_key(), ssl_config);
 
     std::unique_ptr<net::SSLServerSocket> server_socket =
         server_context_->CreateSSLServerSocket(
-            base::WrapUnique(new NetStreamSocketAdapter(std::move(socket))));
+            base::MakeUnique<NetStreamSocketAdapter>(std::move(socket)));
     net::SSLServerSocket* raw_server_socket = server_socket.get();
     socket_ = std::move(server_socket);
     result = raw_server_socket->Handshake(
         base::Bind(&SslHmacChannelAuthenticator::OnConnected,
                    base::Unretained(this)));
 #endif
   } else {
     transport_security_state_.reset(new net::TransportSecurityState);
     cert_verifier_.reset(new FailingCertVerifier);
     ct_verifier_.reset(new IgnoresCTVerifier);
@@ skipping 15 matching lines @@
 
     net::HostPortPair host_and_port(kSslFakeHostName, 0);
     net::SSLClientSocketContext context;
     context.transport_security_state = transport_security_state_.get();
     context.cert_verifier = cert_verifier_.get();
     context.cert_transparency_verifier = ct_verifier_.get();
     context.ct_policy_enforcer = ct_policy_enforcer_.get();
     std::unique_ptr<net::ClientSocketHandle> socket_handle(
         new net::ClientSocketHandle);
     socket_handle->SetSocket(
-        base::WrapUnique(new NetStreamSocketAdapter(std::move(socket))));
+        base::MakeUnique<NetStreamSocketAdapter>(std::move(socket)));
 
 #if defined(OS_NACL)
     // net_nacl doesn't include ClientSocketFactory.
     socket_.reset(new net::SSLClientSocketImpl(
         std::move(socket_handle), host_and_port, ssl_config, context));
 #else
     socket_ =
         net::ClientSocketFactory::GetDefaultFactory()->CreateSSLClientSocket(
             std::move(socket_handle), host_and_port, ssl_config, context);
 #endif
@@ skipping 147 matching lines @@
                                 &(auth_bytes[0]), kAuthDigestLength);
 }
 
 void SslHmacChannelAuthenticator::CheckDone(bool* callback_called) {
   if (auth_write_buf_.get() == nullptr && auth_read_buf_.get() == nullptr) {
     DCHECK(socket_.get() != nullptr);
     if (callback_called)
       *callback_called = true;
 
     base::ResetAndReturn(&done_callback_)
-        .Run(net::OK, base::WrapUnique(new P2PStreamSocketAdapter(
-                          std::move(socket_), std::move(server_context_))));
+        .Run(net::OK, base::MakeUnique<P2PStreamSocketAdapter>(
+                          std::move(socket_), std::move(server_context_)));
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   base::ResetAndReturn(&done_callback_).Run(error, nullptr);
 }
 
 }  // namespace protocol
 }  // namespace remoting