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

mojo/public/cpp/bindings/lib/control_message_proxy.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/control_message_proxy.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 67 matching lines @@
   auto params_ptr = interface_control::RunMessageParams::New();
   params_ptr->input = std::move(input_ptr);
   size_t size = PrepareToSerialize<interface_control::RunMessageParamsDataView>(
       params_ptr, &context);
   MessageBuilder builder(interface_control::kRunMessageId,
                          Message::kFlagExpectsResponse, size, 0);
 
   interface_control::internal::RunMessageParams_Data* params = nullptr;
   Serialize<interface_control::RunMessageParamsDataView>(
       params_ptr, builder.buffer(), &params, &context);
-  MessageReceiver* responder = new RunResponseForwardToCallback(callback);
-  if (!receiver->AcceptWithResponder(builder.message(), responder))
-    delete responder;
+  std::unique_ptr<MessageReceiver> responder =
+      base::MakeUnique<RunResponseForwardToCallback>(callback);
+  ignore_result(
+      receiver->AcceptWithResponder(builder.message(), std::move(responder)));
 }
 
 Message ConstructRunOrClosePipeMessage(
     interface_control::RunOrClosePipeInputPtr input_ptr) {
   SerializationContext context;
 
   auto params_ptr = interface_control::RunOrClosePipeMessageParams::New();
   params_ptr->input = std::move(input_ptr);
 
   size_t size = PrepareToSerialize<
       interface_control::RunOrClosePipeMessageParamsDataView>(params_ptr,
                                                               &context);
   MessageBuilder builder(interface_control::kRunOrClosePipeMessageId, 0, size,
                          0);
 
   interface_control::internal::RunOrClosePipeMessageParams_Data* params =
       nullptr;
   Serialize<interface_control::RunOrClosePipeMessageParamsDataView>(
       params_ptr, builder.buffer(), &params, &context);
   return std::move(*builder.message());
 }
 
 void SendRunOrClosePipeMessage(
     MessageReceiverWithResponder* receiver,
     interface_control::RunOrClosePipeInputPtr input_ptr) {
   Message message(ConstructRunOrClosePipeMessage(std::move(input_ptr)));
 
-  bool ok = receiver->Accept(&message);
-  ALLOW_UNUSED_LOCAL(ok);
+  ignore_result(receiver->Accept(&message));
 }
 
 void RunVersionCallback(
     const base::Callback<void(uint32_t)>& callback,
     interface_control::RunResponseMessageParamsPtr run_response) {
   uint32_t version = 0u;
   if (run_response->output && run_response->output->is_query_version_result())
     version = run_response->output->get_query_version_result()->version;
   callback.Run(version);
 }
@@ skipping 49 matching lines @@
 }
 
 void ControlMessageProxy::OnConnectionError() {
   encountered_error_ = true;
   if (!run_loop_quit_closure_.is_null())
     RunFlushForTestingClosure();
 }
 
 }  // namespace internal
 }  // namespace mojo