mojo: MessageReceiver*::AcceptWithResponder() now take a unique_ptr to the responder

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 54 matching lines @@
   InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
                                   base::MakeUnique<PassThroughFilter>(), false,
                                   base::ThreadTaskRunnerHandle::Get(), 0u);
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
   base::RunLoop run_loop;
   client0.AcceptWithResponder(
-      &request,
-      new MessageAccumulator(&message_queue, run_loop.QuitClosure()));
+      &request, base::MakeUnique<MessageAccumulator>(&message_queue,
+                                                     run_loop.QuitClosure()));
 
   run_loop.Run();
 
   EXPECT_FALSE(message_queue.IsEmpty());
 
   Message response;
   message_queue.Pop(&response);
 
   EXPECT_EQ(std::string("hello world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 
   // Send a second message on the pipe.
   Message request2;
   AllocRequestMessage(1, "hello again", &request2);
 
   base::RunLoop run_loop2;
   client0.AcceptWithResponder(
-      &request2,
-      new MessageAccumulator(&message_queue, run_loop2.QuitClosure()));
+      &request2, base::MakeUnique<MessageAccumulator>(&message_queue,
+                                                      run_loop2.QuitClosure()));
 
   run_loop2.Run();
 
   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::MakeUnique<PassThroughFilter>(), false,
                                   base::ThreadTaskRunnerHandle::Get(), 0u);
   ResponseGenerator generator;
   InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
                                   base::MakeUnique<PassThroughFilter>(), false,
                                   base::ThreadTaskRunnerHandle::Get(), 0u);
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
-  client0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue));
+  client0.AcceptWithResponder(
+      &request, base::MakeUnique<MessageAccumulator>(&message_queue));
 
   router1_->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE);
   router0_->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE);
 
   EXPECT_FALSE(message_queue.IsEmpty());
 
   Message response;
   message_queue.Pop(&response);
 
   EXPECT_EQ(std::string("hello world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 
   // Send a second message on the pipe.
   Message request2;
   AllocRequestMessage(1, "hello again", &request2);
 
-  client0.AcceptWithResponder(&request2,
-                              new MessageAccumulator(&message_queue));
+  client0.AcceptWithResponder(
+      &request2, base::MakeUnique<MessageAccumulator>(&message_queue));
 
   router1_->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE);
   router0_->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE);
 
   EXPECT_FALSE(message_queue.IsEmpty());
 
   message_queue.Pop(&response);
 
   EXPECT_EQ(std::string("hello again world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
@@ skipping 11 matching lines @@
                                   base::WrapUnique(new PassThroughFilter()),
                                   false, base::ThreadTaskRunnerHandle::Get(),
                                   0u);
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
   base::RunLoop run_loop2;
   client0.AcceptWithResponder(
-      &request,
-      new MessageAccumulator(&message_queue, run_loop2.QuitClosure()));
+      &request, base::MakeUnique<MessageAccumulator>(&message_queue,
+                                                     run_loop2.QuitClosure()));
   run_loop.Run();
 
   // The request has been received but the response has not been sent yet.
   EXPECT_TRUE(message_queue.IsEmpty());
 
   // Send the response.
   EXPECT_TRUE(generator.responder_is_valid());
   generator.CompleteWithResponse();
   run_loop2.Run();
 
   // Check the response.
   EXPECT_FALSE(message_queue.IsEmpty());
   Message response;
   message_queue.Pop(&response);
   EXPECT_EQ(std::string("hello world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 
   // Send a second message on the pipe.
   base::RunLoop run_loop3;
   generator.set_closure(run_loop3.QuitClosure());
   Message request2;
   AllocRequestMessage(1, "hello again", &request2);
 
   base::RunLoop run_loop4;
   client0.AcceptWithResponder(
-      &request2,
-      new MessageAccumulator(&message_queue, run_loop4.QuitClosure()));
+      &request2, base::MakeUnique<MessageAccumulator>(&message_queue,
+                                                      run_loop4.QuitClosure()));
   run_loop3.Run();
 
   // The request has been received but the response has not been sent yet.
   EXPECT_TRUE(message_queue.IsEmpty());
 
   // Send the second response.
   EXPECT_TRUE(generator.responder_is_valid());
   generator.CompleteWithResponse();
   run_loop4.Run();
 
@@ skipping 30 matching lines @@
                                   0u);
   bool error_handler_called1 = false;
   client1.set_connection_error_handler(
       base::Bind(&ForwardErrorHandler, &error_handler_called1,
                  run_loop1.QuitClosure()));
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
-  client0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue));
+  client0.AcceptWithResponder(
+      &request, base::MakeUnique<MessageAccumulator>(&message_queue));
   run_loop3.Run();
 
   // The request has been received but no response has been sent.
   EXPECT_TRUE(message_queue.IsEmpty());
 
   // Destroy the responder MessagerReceiver but don't send any response.
   generator.CompleteWithoutResponse();
   run_loop0.Run();
   run_loop1.Run();
 
@@ skipping 26 matching lines @@
         false, base::ThreadTaskRunnerHandle::Get(), 0u);
     InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
                                     base::MakeUnique<PassThroughFilter>(),
                                     false, base::ThreadTaskRunnerHandle::Get(),
                                     0u);
 
     Message request;
     AllocRequestMessage(1, "hello", &request);
 
     MessageQueue message_queue;
-    client0.AcceptWithResponder(&request,
-                                new MessageAccumulator(&message_queue));
+    client0.AcceptWithResponder(
+        &request, base::MakeUnique<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