Mojo C++ bindings: better log message for serialization warnings.

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
 {%- macro alloc_params(parameters) %}
 {%-   for param in parameters %}
 {%-     if param.kind|is_object_kind  %}
 {{param.kind|cpp_result_type}} p{{loop.index}};
 Deserialize_(params->{{param.name}}.ptr, &p{{loop.index}});
@@ skipping 26 matching lines @@
   size_t payload_size =
       mojo::internal::Align(sizeof({{params_name}}));
 {#--- Computes #}
 {%-   for param in parameters %}
 {%-     if param.kind|is_object_kind %}
   payload_size += GetSerializedSize_(in_{{param.name}});
 {%-     endif %}
 {%-   endfor %}
 {%- endmacro %}
 
-{%- macro build_message(params_name, parameters) -%}
+{%- macro build_message(params_name, parameters, params_description) -%}
   {# TODO(yzshen): Consider refactoring to share code with
      struct_serialization_definition.tmpl #}
   {{params_name}}* params =
       {{params_name}}::New(builder.buffer());
 {#--- Sets #}
 {%   for param in parameters %}
 {%-     if param.kind|is_object_kind %}
 {%-       if param.kind|is_any_array_kind %}
   mojo::SerializeArray_<{{param.kind|get_array_validate_params|indent(24)}}>(
       mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &params->{{param.name}}.ptr);
 {%-       else %}
   Serialize_(mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &params->{{param.name}}.ptr);
 {%-       endif %}
 {%-       if not param.kind|is_nullable_kind %}
   MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
       !params->{{param.name}}.ptr,
-      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER);
+      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+      "null {{param.name}} argument in {{params_description}}");
 {%-       endif %}
 {%-     elif param.kind|is_any_handle_kind %}
 {%-       if param.kind|is_interface_kind or
              param.kind|is_interface_request_kind %}
   // Delegate handle.
   params->{{param.name}} = in_{{param.name}}.PassMessagePipe().release();
 {%-       else %}
   params->{{param.name}} = in_{{param.name}}.release();
 {%-       endif %}
 {%-       if not param.kind|is_nullable_kind %}
   MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
       !params->{{param.name}}.is_valid(),
-      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE);
+      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+      "invalid {{param.name}} argument in {{params_description}}");
 {%-       endif %}
 {%-     else %}
   params->{{param.name}} = in_{{param.name}};
 {%-     endif %}
 {%-   endfor %}
   mojo::Message message;
   params->EncodePointersAndHandles(message.mutable_handles());
   builder.Finish(&message);
 {%- endmacro %}
 
@@ skipping 37 matching lines @@
     : receiver_(receiver) {
 }
 
 {#--- Proxy definitions #}
 
 {%- for method in interface.methods %}
 {%-   set message_name =
           "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-   set params_name =
           "internal::%s_%s_Params_Data"|format(interface.name, method.name) %}
+{%-   set params_description =
+          "%s.%s request"|format(interface.name, method.name) %}
 void {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_request_params("in_", method)}}) {
   {{compute_payload_size(params_name, method.parameters)}}
 
 {%- if method.response_parameters != None %}
   mojo::internal::RequestMessageBuilder builder({{message_name}}, payload_size);
 {%- else %}
   mojo::internal::MessageBuilder builder({{message_name}}, payload_size);
 {%- endif %}
 
-  {{build_message(params_name, method.parameters)}}
+  {{build_message(params_name, method.parameters, params_description)}}
 
 {%- if method.response_parameters != None %}
   mojo::MessageReceiver* responder =
       new {{class_name}}_{{method.name}}_ForwardToCallback(callback);
   if (!receiver_->AcceptWithResponder(&message, responder))
     delete responder;
 {%- else %}
   bool ok MOJO_ALLOW_UNUSED = receiver_->Accept(&message);
   // This return value may be ignored as !ok implies the Connector has
   // encountered an error, which will be visible through other means.
 {%- 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 params_name =
             "internal::%s_%s_ResponseParams_Data"|format(interface.name, method.name) %}
+{%-     set params_description =
+            "%s.%s response"|format(interface.name, method.name) %}
 class {{class_name}}_{{method.name}}_ProxyToResponder
     : public {{interface_macros.declare_callback(method)}}::Runnable {
  public:
   virtual ~{{class_name}}_{{method.name}}_ProxyToResponder() {
     delete responder_;
   }
 
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
       mojo::MessageReceiver* responder)
       : request_id_(request_id),
         responder_(responder) {
   }
 
   virtual void Run({{interface_macros.declare_params("in_", method.response_parameters)}}) const;
 
  private:
   uint64_t request_id_;
   mutable mojo::MessageReceiver* responder_;
   MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_params("in_", method.response_parameters)}}) const {
   {{compute_payload_size(params_name, method.response_parameters)}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, payload_size, request_id_);
-  {{build_message(params_name, method.response_parameters)}}
+  {{build_message(params_name, method.response_parameters, params_description)}}
   bool ok MOJO_ALLOW_UNUSED = responder_->Accept(&message);
   // 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_;
   responder_ = NULL;
 }
 {%-   endif -%}
 {%- endfor %}
 
@@ skipping 115 matching lines @@
       }
       break;
     }
 {%-   endfor %}
   }
 {%- endif %}
 
   return sink_->Accept(message);
 }
 {%- endif -%}