Mojo C++ Bindings: Support custom impl ref types

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 277 matching lines @@
   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) {
-}
+{#--- StubDispatch definition #}
 
-{{class_name}}Stub::~{{interface.name}}Stub() {}
-
-{#--- Stub definition #}
-
-bool {{class_name}}Stub::Accept(mojo::Message* message) {
+// static
+bool {{class_name}}StubDispatch::Accept(
+    {{interface.name}}* impl,
+    mojo::internal::SerializationContext* context,
+    mojo::Message* message) {
 {%- 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());
 
 {%-       set desc = class_name~"::"~method.name %}
-      {{alloc_params(method.param_struct, "params", "message",
-          "&serialization_context_", desc)|indent(4)}}
-      // A null |sink_| means no implementation was bound.
-      assert(sink_);
+      {{alloc_params(method.param_struct, "params", "message", "context", desc)|
+          indent(4)}}
+      // A null |impl| means no implementation was bound.
+      assert(impl);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       mojo::internal::MessageDispatchContext context(message);
-      sink_->{{method.name}}({{pass_params(method.parameters)}});
+      impl->{{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) {
+// static
+bool {{class_name}}StubDispatch::AcceptWithResponder(
+    {{interface.name}}* impl,
+    mojo::internal::SerializationContext* context,
+    mojo::Message* message,
+    mojo::MessageReceiverWithStatus* responder) {
 {%- 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());
 
 {%-       set desc = class_name~"::"~method.name %}
-      {{alloc_params(method.param_struct, "params", "message",
-          "&serialization_context_", desc)|
-              indent(4)}}
+      {{alloc_params(method.param_struct, "params", "message", "context", desc)|
+          indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
-              message->has_flag(mojo::Message::kFlagIsSync),
-              responder,
-              serialization_context_.group_controller);
-      // A null |sink_| means no implementation was bound.
-      assert(sink_);
+              message->has_flag(mojo::Message::kFlagIsSync), responder,
+              context->group_controller);
+      // A null |impl| means no implementation was bound.
+      assert(impl);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       mojo::internal::MessageDispatchContext context(message);
-      sink_->{{method.name}}(
+      impl->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
@@ skipping 69 matching lines @@
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}