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

mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- import "struct_macros.tmpl" as struct_macros %}
 
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
 {%- macro alloc_params(struct, params, message, description) %}
   mojo::internal::SerializationContext serialization_context;
   serialization_context.handles.Swap(({{message}})->mutable_handles());
@@ skipping 151 matching lines @@
 
   mojo::internal::MessageBuilder builder(
       {{message_name}},
       mojo::Message::kFlagIsSync | mojo::Message::kFlagExpectsResponse,
       size, serialization_context.associated_endpoint_count);
 
   {{build_message(params_struct, "param_%s", params_description,
                   "&serialization_context")}}
 
   bool result = false;
-  mojo::MessageReceiver* responder =
+  std::unique_ptr<mojo::MessageReceiver> responder(
       new {{class_name}}_{{method.name}}_HandleSyncResponse(
           &result
 {%-     for param in method.response_parameters -%}
           , param_{{param.name}}
-{%-     endfor %});
-  if (!receiver_->AcceptWithResponder(builder.message(), responder))
-    delete responder;
+{%-     endfor %}));
+  ignore_result(receiver_->AcceptWithResponder(builder.message(),
+                                               std::move(responder)));
   return result;
 }
 {%-   endif %}
 
 void {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_request_params("in_", method, use_once_callback)}}) {
   mojo::internal::SerializationContext serialization_context;
   {{struct_macros.get_serialized_size(params_struct, "in_%s",
                                       "&serialization_context")}}
 
 {%- if method.response_parameters != None %}
   constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
 {%- else %}
   constexpr uint32_t kFlags = 0;
 {%- endif %}
   mojo::internal::MessageBuilder builder(
       {{message_name}}, kFlags, size,
       serialization_context.associated_endpoint_count);
 
   {{build_message(params_struct, "in_%s", params_description,
                   "&serialization_context")}}
 
 {%- if method.response_parameters != None %}
-  mojo::MessageReceiver* responder =
-      new {{class_name}}_{{method.name}}_ForwardToCallback(std::move(callback));
-  if (!receiver_->AcceptWithResponder(builder.message(), responder))
-    delete responder;
+  std::unique_ptr<mojo::MessageReceiver> responder(
+      new {{class_name}}_{{method.name}}_ForwardToCallback(
+          std::move(callback)));
+  ignore_result(receiver_->AcceptWithResponder(builder.message(),
+                                               std::move(responder)));
 {%- else %}
-  bool ok = receiver_->Accept(builder.message());
-  // This return value may be ignored as !ok implies the Connector has
+  // This return value may be ignored as false implies the Connector has
   // encountered an error, which will be visible through other means.
-  ALLOW_UNUSED_LOCAL(ok);
+  ignore_result(receiver_->Accept(builder.message()));
 {%- endif %}
 }
 {%- endfor %}
 
 {#--- ProxyToResponder definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     set message_name =
             "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-     set response_params_struct = method.response_param_struct %}
 {%-     set params_description =
             "%s.%s response"|format(interface.name, method.name) %}
 class {{class_name}}_{{method.name}}_ProxyToResponder {
  public:
   static {{class_name}}::{{method.name}}Callback CreateCallback(
       uint64_t request_id,
       bool is_sync,
-      mojo::MessageReceiverWithStatus* responder) {
+      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
     std::unique_ptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy(
         new {{class_name}}_{{method.name}}_ProxyToResponder(
-            request_id, is_sync, responder));
+            request_id, is_sync, std::move(responder)));
     return base::Bind(&{{class_name}}_{{method.name}}_ProxyToResponder::Run,
                       base::Passed(&proxy));
   }
 
   ~{{class_name}}_{{method.name}}_ProxyToResponder() {
 #if DCHECK_IS_ON()
     if (responder_) {
       // Is the Service destroying the callback without running it
       // and without first closing the pipe?
       responder_->DCheckInvalid("The callback passed to "
           "{{class_name}}::{{method.name}}() was never run.");
     }
 #endif
     // If the Callback was dropped then deleting the responder will close
     // the pipe so the calling application knows to stop waiting for a reply.
-    delete responder_;
+    responder_ = nullptr;
   }
 
  private:
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
       bool is_sync,
-      mojo::MessageReceiverWithStatus* responder)
+      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
       : request_id_(request_id),
         is_sync_(is_sync),
-        responder_(responder) {
+        responder_(std::move(responder)) {
   }
 
   void Run(
       {{interface_macros.declare_responder_params(
           "in_", method.response_parameters, for_blink)}});
 
   uint64_t request_id_;
   bool is_sync_;
-  mojo::MessageReceiverWithStatus* responder_;
+  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;
 
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_responder_params(
         "in_", method.response_parameters, for_blink)}}) {
   mojo::internal::SerializationContext serialization_context;
   {{struct_macros.get_serialized_size(response_params_struct, "in_%s",
                                       "&serialization_context")}}
 
   uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                    mojo::Message::kFlagIsResponse;
   mojo::internal::MessageBuilder builder(
       {{message_name}}, flags, size,
       serialization_context.associated_endpoint_count);
   builder.message()->set_request_id(request_id_);
 
   {{build_message(response_params_struct, "in_%s", params_description,
                   "&serialization_context")}}
-  bool ok = responder_->Accept(builder.message());
-  ALLOW_UNUSED_LOCAL(ok);
-  // TODO(darin): !ok returned here indicates a malformed message, and that may
-  // be good reason to close the connection. However, we don't have a way to do
-  // that from here. We should add a way.
-  delete responder_;
+  ignore_result(responder_->Accept(builder.message()));
+  // TODO(darin): Accept() returning false indicates a malformed message, and
+  // that may be good reason to close the connection. However, we don't have a
+  // way to do that from here. We should add a way.
   responder_ = nullptr;
 }
 {%-   endif -%}
 {%- endfor %}
 
 {#--- StubDispatch definition #}
 
 // static
 bool {{class_name}}StubDispatch::Accept(
     {{interface.name}}* impl,
@@ skipping 23 matching lines @@
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }
 
 // static
 bool {{class_name}}StubDispatch::AcceptWithResponder(
     {{interface.name}}* impl,
     mojo::Message* message,
-    mojo::MessageReceiverWithStatus* responder) {
+    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
 {%- if interface.methods %}
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-     if method.response_parameters != None %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
 {%-       set desc = class_name~"::"~method.name %}
       {{alloc_params(method.param_struct, "params", "message", desc)|
           indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
-              message->has_flag(mojo::Message::kFlagIsSync), responder);
+              message->has_flag(mojo::Message::kFlagIsSync),
+              std::move(responder));
       // A null |impl| means no implementation was bound.
       assert(impl);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       mojo::internal::MessageDispatchContext context(message);
       impl->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}std::move(callback));
       return true;
 {%-     else %}
       break;
 {%-     endif %}
@@ skipping 76 matching lines @@
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}