Mojo C++ bindings: support passing associated interface pointers/requests in method parameter lists…

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- import "struct_macros.tmpl" as struct_macros %}
 {%- from "enum_macros.tmpl" import is_valid_enum_def %}
 
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
-{%- macro alloc_params(struct) %}
+{%- macro alloc_params(struct, serialization_context) %}
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_result_type}} p_{{param.field.name}}{};
 {%-   endfor %}
-  {{struct_macros.deserialize(struct, "params", "p_%s")}}
+  {{struct_macros.deserialize(struct, "params", "p_%s", serialization_context)}}
 {%- endmacro %}
 
 {%- macro pass_params(parameters) %}
 {%-   for param in parameters %}
 {%-     if param.kind|is_move_only_kind -%}
 p_{{param.name}}.Pass()
 {%-     else -%}
 p_{{param.name}}
 {%-     endif -%}
 {%-     if not loop.last %}, {% endif %}
@@ skipping 23 matching lines @@
   {{is_valid_enum_def(enum, class_name=interface.name)|indent(2)}}
 {%- endfor %}
 
 {#--- ForwardToCallback definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 class {{class_name}}_{{method.name}}_ForwardToCallback
     : public mojo::MessageReceiver {
  public:
   {{class_name}}_{{method.name}}_ForwardToCallback(
-      const {{class_name}}::{{method.name}}Callback& callback)
-      : callback_(callback) {
+      const {{class_name}}::{{method.name}}Callback& callback,
+      scoped_refptr<mojo::internal::MultiplexRouter> router)
+      : callback_(callback), serialization_context_(router.Pass()) {
   }
   bool Accept(mojo::Message* message) override;
  private:
   {{class_name}}::{{method.name}}Callback callback_;
+  mojo::internal::SerializationContext serialization_context_;
   MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback);
 };
 bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
     mojo::Message* message) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
   params->DecodePointersAndHandles(message->mutable_handles());
-  {{alloc_params(method.response_param_struct)}}
+  {{alloc_params(method.response_param_struct, "&serialization_context_")}}
   callback_.Run({{pass_params(method.response_parameters)}});
   return true;
 }
 {%-   endif %}
 {%- endfor %}
 
 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver)
     : ControlMessageProxy(receiver) {
 }
 
@@ skipping 12 matching lines @@
 {%- 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, params_description)}}
 
 {%- if method.response_parameters != None %}
   mojo::MessageReceiver* responder =
-      new {{class_name}}_{{method.name}}_ForwardToCallback(callback);
+      new {{class_name}}_{{method.name}}_ForwardToCallback(callback, serialization_context_.router);
   if (!receiver_->AcceptWithResponder(builder.message(), responder))
     delete responder;
 {%- else %}
   bool ok = receiver_->Accept(builder.message());
   // This return value may be ignored as !ok implies the Connector has
   // encountered an error, which will be visible through other means.
   MOJO_ALLOW_UNUSED_LOCAL(ok);
 {%- endif %}
 }
 {%- endfor %}
@@ skipping 68 matching lines @@
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
       mojo::internal::ScopedTaskTracking task_id("mojo.{{namespace_as_string}}.{{class_name}}.{{method.name}}", __FILE__, __LINE__);
 {%-     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());
 
       params->DecodePointersAndHandles(message->mutable_handles());
-      {{alloc_params(method.param_struct)|indent(4)}}
+      {{alloc_params(method.param_struct, "&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 %}
@@ skipping 14 matching lines @@
 {%-     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());
 
       params->DecodePointersAndHandles(message->mutable_handles());
       {{class_name}}::{{method.name}}Callback::Runnable* runnable =
           new {{class_name}}_{{method.name}}_ProxyToResponder(
               message->request_id(), responder);
       {{class_name}}::{{method.name}}Callback callback(runnable);
-      {{alloc_params(method.param_struct)|indent(4)}}
+      {{alloc_params(method.param_struct, "&serialization_context_")|indent(4)}}
       // A null |sink_| means no implementation was bound.
       assert(sink_);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
@@ skipping 75 matching lines @@
     default:
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}