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

mojo/public/cpp/bindings/tests/multiplex_router_unittest.cc

 // Copyright 2015 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 "mojo/public/cpp/bindings/lib/multiplex_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 47 matching lines @@
   scoped_refptr<MultiplexRouter> router1_;
   ScopedInterfaceEndpointHandle endpoint0_;
   ScopedInterfaceEndpointHandle endpoint1_;
 
  private:
   base::MessageLoop loop_;
 };
 
 TEST_F(MultiplexRouterTest, BasicRequestResponse) {
   InterfaceEndpointClient client0(std::move(endpoint0_), nullptr,
-                                  base::WrapUnique(new PassThroughFilter()),
-                                  false, base::ThreadTaskRunnerHandle::Get());
+                                  base::MakeUnique<PassThroughFilter>(), false,
+                                  base::ThreadTaskRunnerHandle::Get());
   ResponseGenerator generator;
   InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
-                                  base::WrapUnique(new PassThroughFilter()),
-                                  false, base::ThreadTaskRunnerHandle::Get());
+                                  base::MakeUnique<PassThroughFilter>(), false,
+                                  base::ThreadTaskRunnerHandle::Get());
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
   base::RunLoop run_loop;
   client0.AcceptWithResponder(
       &request,
       new MessageAccumulator(&message_queue, run_loop.QuitClosure()));
 
@@ skipping 21 matching lines @@
   EXPECT_FALSE(message_queue.IsEmpty());
 
   message_queue.Pop(&response);
 
   EXPECT_EQ(std::string("hello again world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 }
 
 TEST_F(MultiplexRouterTest, BasicRequestResponse_Synchronous) {
   InterfaceEndpointClient client0(std::move(endpoint0_), nullptr,
-                                  base::WrapUnique(new PassThroughFilter()),
-                                  false, base::ThreadTaskRunnerHandle::Get());
+                                  base::MakeUnique<PassThroughFilter>(), false,
+                                  base::ThreadTaskRunnerHandle::Get());
   ResponseGenerator generator;
   InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
-                                  base::WrapUnique(new PassThroughFilter()),
-                                  false, base::ThreadTaskRunnerHandle::Get());
+                                  base::MakeUnique<PassThroughFilter>(), false,
+                                  base::ThreadTaskRunnerHandle::Get());
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
   client0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue));
 
   router1_->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE);
   router0_->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE);
 
@@ skipping 18 matching lines @@
   EXPECT_FALSE(message_queue.IsEmpty());
 
   message_queue.Pop(&response);
 
   EXPECT_EQ(std::string("hello again world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 }
 
 TEST_F(MultiplexRouterTest, RequestWithNoReceiver) {
   InterfaceEndpointClient client0(std::move(endpoint0_), nullptr,
-                                  base::WrapUnique(new PassThroughFilter()),
-                                  false, base::ThreadTaskRunnerHandle::Get());
+                                  base::MakeUnique<PassThroughFilter>(), false,
+                                  base::ThreadTaskRunnerHandle::Get());
   InterfaceEndpointClient client1(std::move(endpoint1_), nullptr,
-                                  base::WrapUnique(new PassThroughFilter()),
-                                  false, base::ThreadTaskRunnerHandle::Get());
+                                  base::MakeUnique<PassThroughFilter>(), false,
+                                  base::ThreadTaskRunnerHandle::Get());
 
   // Without an incoming receiver set on client1, we expect client0 to observe
   // an error as a result of sending a message.
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
   base::RunLoop run_loop, run_loop2;
   client0.set_connection_error_handler(run_loop.QuitClosure());
@@ skipping 134 matching lines @@
 
 TEST_F(MultiplexRouterTest, LateResponse) {
   // Test that things won't blow up if we try to send a message to a
   // MessageReceiver, which was given to us via AcceptWithResponder,
   // after the router has gone away.
 
   base::RunLoop run_loop;
   LazyResponseGenerator generator(run_loop.QuitClosure());
   {
     InterfaceEndpointClient client0(std::move(endpoint0_), nullptr,
-                                    base::WrapUnique(new PassThroughFilter()),
+                                    base::MakeUnique<PassThroughFilter>(),
                                     false, base::ThreadTaskRunnerHandle::Get());
     InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
-                                    base::WrapUnique(new PassThroughFilter()),
+                                    base::MakeUnique<PassThroughFilter>(),
                                     false, base::ThreadTaskRunnerHandle::Get());
 
     Message request;
     AllocRequestMessage(1, "hello", &request);
 
     MessageQueue message_queue;
     client0.AcceptWithResponder(&request,
                                 new MessageAccumulator(&message_queue));
 
     run_loop.Run();
 
     EXPECT_TRUE(generator.has_responder());
   }
 
   EXPECT_FALSE(generator.responder_is_valid());
   generator.CompleteWithResponse();  // This should end up doing nothing.
 }
 
 // TODO(yzshen): add more tests.
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo