Support custom message filtering on Mojo binding objects

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,
                        description) %}
   ({{serialization_context}})->handles.Swap(({{message}})->mutable_handles());
@@ skipping 359 matching lines @@
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- 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) {
-  assert(sink_);
-
   mojo::internal::ValidationContext validation_context(
     message->data(), message->data_num_bytes(), message->handles()->size(),
     message, "{{class_name}} RequestValidator");
 
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) {
     if (!mojo::internal::ValidateControlRequest(message, &validation_context))
       return false;
-    return sink_->Accept(message);
+    return true;
   }
 
   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, &validation_context)) {
         return false;
       }
 {%-   else %}
       if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
               message, &validation_context)) {
         return false;
       }
 {%-   endif %}
       if (!mojo::internal::ValidateMessagePayload<
                internal::{{class_name}}_{{method.name}}_Params_Data>(
                   message, &validation_context)) {
         return false;
       }
-      return sink_->Accept(message);
+      return true;
     }
 {%- endfor %}
     default:
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       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) {
-  assert(sink_);
-
   mojo::internal::ValidationContext validation_context(
     message->data(), message->data_num_bytes(), message->handles()->size(),
     message, "{{class_name}} ResponseValidator");
 
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) {
     if (!mojo::internal::ValidateControlResponse(message, &validation_context))
       return false;
-    return sink_->Accept(message);
+    return true;
   }
 
   if (!mojo::internal::ValidateMessageIsResponse(message, &validation_context))
     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, &validation_context)) {
         return false;
       }
-      return sink_->Accept(message);
+      return true;
     }
 {%- endfor %}
     default:
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}