Mojo: Report bindings validation errors via MojoNotifyBadMessage

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, serialization_context) %}
+{%- macro alloc_params(struct, params, message, error, create_error,
+                       method_name, serialization_context) %}
   ({{params}})->DecodePointers();
   ({{serialization_context}})->handles.Swap(({{message}})->mutable_handles());
   bool success = true;
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_wrapper_type}} p_{{param.field.name}}{};
 {%-   endfor %}
   {{struct.name}}DataView input_data_view({{params}},
                                           {{serialization_context}});
   {{struct_macros.deserialize(struct, "input_data_view", "p_%s", "success")}}
-  if (!success)
+  if (!success) {
+    *{{error}} = {{create_error}}("{{class_name}}", "{{method_name}}",
+                                  {{message}});
     return false;
+  }
 {%- endmacro %}
 
 {%- macro pass_params(parameters) %}
 {%-   for param in parameters %}
 {%-     if param.kind|is_move_only_kind -%}
 std::move(p_{{param.name}})
 {%-     else -%}
 p_{{param.name}}
 {%-     endif -%}
 {%-     if not loop.last %}, {% endif %}
@@ skipping 45 matching lines @@
       scoped_refptr<mojo::internal::MultiplexRouter> router, bool* result
 {%-       for param in method.response_parameters -%}
       , {{param.kind|cpp_wrapper_type}}* out_{{param.name}}
 {%-       endfor %})
       : serialization_context_(std::move(router)), result_(result)
 {%-       for param in method.response_parameters -%}
         , out_{{param.name}}_(out_{{param.name}})
 {%-       endfor %} {
     DCHECK(!*result_);
   }
-  bool Accept(mojo::Message* message) override;
+  bool Accept(mojo::Message* message, mojo::Error* error) override;
  private:
   mojo::internal::SerializationContext serialization_context_;
   bool* result_;
 {%-       for param in method.response_parameters %}
   {{param.kind|cpp_wrapper_type}}* out_{{param.name}}_;
 {%-       endfor -%}
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_HandleSyncResponse);
 };
 bool {{class_name}}_{{method.name}}_HandleSyncResponse::Accept(
-    mojo::Message* message) {
+    mojo::Message* message, mojo::Error* error) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
-  {{alloc_params(method.response_param_struct, "params", "message",
+  {{alloc_params(method.response_param_struct, "params", "message", "error",
+                 "mojo::Error::ForBadResponse", method.name,
                  "&serialization_context_")}}
 
 {%-       for param in method.response_parameters %}
 {%-         if param.kind|is_move_only_kind %}
   *out_{{param.name}}_ = std::move(p_{{param.name}});
 {%-         else %}
   *out_{{param.name}}_ = p_{{param.name}};
 {%-         endif %}
 {%-       endfor %}
   *result_ = true;
   return true;
 }
 {%-     endif %}
 
 class {{class_name}}_{{method.name}}_ForwardToCallback
     : public mojo::MessageReceiver {
  public:
   {{class_name}}_{{method.name}}_ForwardToCallback(
       const {{class_name}}::{{method.name}}Callback& callback,
       scoped_refptr<mojo::internal::MultiplexRouter> router)
       : callback_(callback), serialization_context_(std::move(router)) {
   }
-  bool Accept(mojo::Message* message) override;
+  bool Accept(mojo::Message* message, mojo::Error* error) override;
  private:
   {{class_name}}::{{method.name}}Callback callback_;
   mojo::internal::SerializationContext serialization_context_;
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback);
 };
 bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
-    mojo::Message* message) {
+    mojo::Message* message, mojo::Error* error) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
-  {{alloc_params(method.response_param_struct, "params", "message",
+  {{alloc_params(method.response_param_struct, "params", "message", "error",
+                 "mojo::Error::ForBadResponse", method.name,
                  "&serialization_context_")}}
   callback_.Run({{pass_params(method.response_parameters)}});
   return true;
 }
 {%-   endif %}
 {%- endfor %}
 
 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver)
     : ControlMessageProxy(receiver) {
 }
@@ skipping 18 matching lines @@
   {{build_message(params_struct, "param_%s", params_description,
                   "&serialization_context_")}}
 
   bool result = false;
   mojo::MessageReceiver* responder =
       new {{class_name}}_{{method.name}}_HandleSyncResponse(
           serialization_context_.router, &result
 {%-     for param in method.response_parameters -%}
           , param_{{param.name}}
 {%-     endfor %});
-  if (!receiver_->AcceptWithResponder(builder.message(), responder))
+  mojo::Error send_error;
+  if (!receiver_->AcceptWithResponder(builder.message(), responder,
+                                      &send_error)) {
     delete responder;
+  }
   return result;
 }
 {%-   endif %}
 
 void {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_request_params("in_", method)}}) {
   {{struct_macros.get_serialized_size(params_struct, "in_%s",
                                       "&serialization_context_")}}
 
 {%- if method.response_parameters != None %}
   mojo::internal::RequestMessageBuilder builder({{message_name}}, size);
 {%- else %}
   mojo::internal::MessageBuilder builder({{message_name}}, size);
 {%- endif %}
 
   {{build_message(params_struct, "in_%s", params_description,
                   "&serialization_context_")}}
 
 {%- if method.response_parameters != None %}
   mojo::MessageReceiver* responder =
-      new {{class_name}}_{{method.name}}_ForwardToCallback(callback, serialization_context_.router);
-  if (!receiver_->AcceptWithResponder(builder.message(), responder))
+      new {{class_name}}_{{method.name}}_ForwardToCallback(
+          callback, serialization_context_.router);
+  mojo::Error send_error;
+  if (!receiver_->AcceptWithResponder(builder.message(), responder,
+                                      &send_error)) {
     delete responder;
+  }
 {%- else %}
-  bool ok = receiver_->Accept(builder.message());
+  mojo::Error send_response_error;
+  bool ok = receiver_->Accept(builder.message(), &send_response_error);
   // This return value may be ignored as !ok implies the Connector has
   // encountered an error, which will be visible through other means.
   ALLOW_UNUSED_LOCAL(ok);
 {%- endif %}
 }
 {%- endfor %}
 
 {#--- ProxyToResponder definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
@@ skipping 43 matching lines @@
 };
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_params("in_", method.response_parameters)}}) {
   {{struct_macros.get_serialized_size(response_params_struct, "in_%s",
                                       "&serialization_context_")}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, size, request_id_,
       is_sync_ ? mojo::internal::kMessageIsSync : 0);
   {{build_message(response_params_struct, "in_%s", params_description,
                   "&serialization_context_")}}
-  bool ok = responder_->Accept(builder.message());
+  mojo::Error send_response_error;
+  bool ok = responder_->Accept(builder.message(), &send_response_error);
   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_;
   responder_ = nullptr;
 }
 {%-   endif -%}
 {%- endfor %}
 
 {{class_name}}Stub::{{class_name}}Stub()
     : sink_(nullptr),
       control_message_handler_({{interface.name}}::Version_) {
 }
 
 {{class_name}}Stub::~{{interface.name}}Stub() {}
 
 {#--- Stub definition #}
 
-bool {{class_name}}Stub::Accept(mojo::Message* message) {
+bool {{class_name}}Stub::Accept(mojo::Message* message, mojo::Error* error) {
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
-    return control_message_handler_.Accept(message);
+    return control_message_handler_.Accept(message, error);
 {%- 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());
 
-      {{alloc_params(method.param_struct, "params", "message",
+      {{alloc_params(method.param_struct, "params", "message", "error",
+          "mojo::Error::ForBadRequest", method.name,
           "&serialization_context_")|indent(4)}}
       // A null |sink_| means no implementation was bound.
       assert(sink_);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       sink_->{{method.name}}({{pass_params(method.parameters)}});
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }
 
 bool {{class_name}}Stub::AcceptWithResponder(
-    mojo::Message* message, mojo::MessageReceiverWithStatus* responder) {
-  if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
-    return control_message_handler_.AcceptWithResponder(message, responder);
+    mojo::Message* message,
+    mojo::MessageReceiverWithStatus* responder,
+    mojo::Error* error) {
+  if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) {
+    return control_message_handler_.AcceptWithResponder(message, responder,
+                                                        error);
+  }
 {%- 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());
 
-      {{alloc_params(method.param_struct, "params", "message",
+      {{alloc_params(method.param_struct, "params", "message", "error",
+          "mojo::Error::ForBadRequest", method.name,
           "&serialization_context_")|indent(4)}}
       {{class_name}}::{{method.name}}Callback::Runnable* runnable =
           new {{class_name}}_{{method.name}}_ProxyToResponder(
               message->request_id(),
               message->has_flag(mojo::internal::kMessageIsSync),
               responder,
               serialization_context_.router);
       {{class_name}}::{{method.name}}Callback callback(runnable);
       // A null |sink_| means no implementation was bound.
       assert(sink_);
@@ skipping 10 matching lines @@
 {%- endif %}
   return false;
 }
 
 {#--- Request validator definitions #}
 
 {{class_name}}RequestValidator::{{class_name}}RequestValidator(
     mojo::MessageReceiver* sink) : MessageFilter(sink) {
 }
 
-bool {{class_name}}RequestValidator::Accept(mojo::Message* message) {
+bool {{class_name}}RequestValidator::Accept(mojo::Message* message,
+                                            mojo::Error* error) {
   assert(sink_);
 
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) {
-    if (!mojo::internal::ValidateControlRequest(message))
+    if (!mojo::internal::ValidateControlRequest(message)) {
+      *error = mojo::Error::ForBadControlMessage("{{class_name}}", message);
       return false;
-    return sink_->Accept(message);
+    }
+    return sink_->Accept(message, error);
   }
 
   switch (message->header()->name) {
 {%- for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-   if method.response_parameters != None %}
-      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(message))
+      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(message)) {
+        *error = mojo::Error::ForBadRequest(
+            "{{class_name}}", "{{method.name}}", message);
         return false;
+      }
 {%-   else %}
-      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(message))
+      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(message)) {
+        *error = mojo::Error::ForBadRequest(
+            "{{class_name}}", "{{method.name}}", message);
         return false;
+      }
 {%-   endif %}
       if (!mojo::internal::ValidateMessagePayload<
                internal::{{class_name}}_{{method.name}}_Params_Data>(message)) {
+        *error = mojo::Error::ForBadRequest(
+            "{{class_name}}", "{{method.name}}", message);
         return false;
       }
-      return sink_->Accept(message);
+      return sink_->Accept(message, error);
     }
 {%- endfor %}
     default:
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 
 {#--- Response validator definitions #}
 {% if interface|has_callbacks %}
 {{class_name}}ResponseValidator::{{class_name}}ResponseValidator(
     mojo::MessageReceiver* sink) : MessageFilter(sink) {
 }
 
-bool {{class_name}}ResponseValidator::Accept(mojo::Message* message) {
+bool {{class_name}}ResponseValidator::Accept(mojo::Message* message,
+                                             mojo::Error* error) {
   assert(sink_);
 
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) {
-    if (!mojo::internal::ValidateControlResponse(message))
+    if (!mojo::internal::ValidateControlResponse(message)) {
+      *error = mojo::Error::ForBadControlMessage("{{class_name}}", message);
       return false;
-    return sink_->Accept(message);
+    }
+    return sink_->Accept(message, error);
   }
 
-  if (!mojo::internal::ValidateMessageIsResponse(message))
+  if (!mojo::internal::ValidateMessageIsResponse(message)) {
+    *error = mojo::Error::ForUnexpectedRequest("{{class_name}}", message);
     return false;
+  }
   switch (message->header()->name) {
 {%- for method in interface.methods if method.response_parameters != None %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
       if (!mojo::internal::ValidateMessagePayload<
-               internal::{{class_name}}_{{method.name}}_ResponseParams_Data>(message)) {
+               internal::{{class_name}}_{{method.name}}_ResponseParams_Data>(
+                    message)) {
+        *error = mojo::Error::ForBadResponse(
+            "{{class_name}}", "{{method.name}}", message);
         return false;
       }
-      return sink_->Accept(message);
+      return sink_->Accept(message, error);
     }
 {%- endfor %}
     default:
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
+  *error = mojo::Error::ForUnexpectedResponse("{{class_name}}", message);
   return false;
 }
 {%- endif -%}