Cpp bindings: Return false from Validator::Accept() on unrecognized message or invalid flags

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) %}
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_result_type}} p_{{param.field.name}}{};
 {%-   endfor %}
@@ skipping 209 matching lines @@
 }
 
 {#--- Request validator definitions #}
 
 {{class_name}}RequestValidator::{{class_name}}RequestValidator(
     mojo::MessageReceiver* sink) : MessageFilter(sink) {
 }
 
 bool {{class_name}}RequestValidator::Accept(mojo::Message* message) {
 {%- if interface.methods %}
+  if (message->has_flag(mojo::internal::kMessageIsResponse)) {
+    ReportValidationError(
+        mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAG_COMBINATION);
+    return false;
+  }
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-     if method.response_parameters != None %}
-      if (!message->has_flag(mojo::internal::kMessageExpectsResponse))
-        break;
+      if (!message->has_flag(mojo::internal::kMessageExpectsResponse)) {
+        ReportValidationError(
+            mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAG_COMBINATION);
+        return false;
+      }
 {%-     else %}
-      if (message->has_flag(mojo::internal::kMessageExpectsResponse) ||
-          message->has_flag(mojo::internal::kMessageIsResponse)) {
-        break;
+      if (message->has_flag(mojo::internal::kMessageExpectsResponse)) {
+        ReportValidationError(
+            mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAG_COMBINATION);
+        return false;
       }
 {%-     endif %}
       mojo::internal::BoundsChecker bounds_checker(
           message->payload(), message->payload_num_bytes(),
           message->handles()->size());
       if (!internal::{{class_name}}_{{method.name}}_Params_Data::Validate(
               message->payload(), &bounds_checker)) {
         return false;
       }
       break;
     }
 {%-   endfor %}
+    default: {
+      // Unrecognized message.
+      ReportValidationError(
+          mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
+      return false;
+    }
   }
 {%- endif %}
 
   assert(sink_);
   return sink_->Accept(message);
 }
 
 {#--- 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) {
 {%- if interface.methods %}
+  if (!message->has_flag(mojo::internal::kMessageIsResponse)) {
+    ReportValidationError(
+        mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAG_COMBINATION);
+    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 (!message->has_flag(mojo::internal::kMessageIsResponse))
-        break;
       mojo::internal::BoundsChecker bounds_checker(
           message->payload(), message->payload_num_bytes(),
           message->handles()->size());
       if (!internal::{{class_name}}_{{method.name}}_ResponseParams_Data::Validate(
               message->payload(), &bounds_checker)) {
         return false;
       }
       break;
     }
 {%-   endfor %}
+    default: {
+      // Unrecognized message.
+      ReportValidationError(
+          mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
+      return false;
+    }
   }
 {%- endif %}
 
   assert(sink_);
   return sink_->Accept(message);
 }
 {%- endif -%}