Mojo C++ Bindings: Extract AssociatedGroupController from MultiplexRouter

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) %}
   ({{params}})->DecodePointers();
@@ skipping 59 matching lines @@
 {%- endfor %}
 
 {#--- ForwardToCallback definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     if method.sync %}
 class {{class_name}}_{{method.name}}_HandleSyncResponse
     : public mojo::MessageReceiver {
  public:
   {{class_name}}_{{method.name}}_HandleSyncResponse(
-      scoped_refptr<mojo::internal::MultiplexRouter> router, bool* result
+      scoped_refptr<mojo::AssociatedGroupController> group_controller,
+      bool* result
 {%-       for param in method.response_parameters -%}
       , {{param.kind|cpp_wrapper_type}}* out_{{param.name}}
 {%-       endfor %})
-      : serialization_context_(std::move(router)), result_(result)
+      : serialization_context_(std::move(group_controller)), result_(result)
 {%-       for param in method.response_parameters -%}
         , out_{{param.name}}_(out_{{param.name}})
 {%-       endfor %} {
     DCHECK(!*result_);
   }
   bool Accept(mojo::Message* message) override;
  private:
   mojo::internal::SerializationContext serialization_context_;
   bool* result_;
 {%-       for param in method.response_parameters %}
@@ skipping 17 matching lines @@
   *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)) {
+      scoped_refptr<mojo::AssociatedGroupController> group_controller)
+      : callback_(callback),
+        serialization_context_(std::move(group_controller)) {
   }
   bool Accept(mojo::Message* message) 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) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
@@ skipping 30 matching lines @@
 
   mojo::internal::RequestMessageBuilder builder({{message_name}}, size,
                                                 mojo::internal::kMessageIsSync);
 
   {{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
+          serialization_context_.group_controller, &result
 {%-     for param in method.response_parameters -%}
           , param_{{param.name}}
 {%-     endfor %});
   if (!receiver_->AcceptWithResponder(builder.message(), responder))
     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);
+      new {{class_name}}_{{method.name}}_ForwardToCallback(
+          callback, serialization_context_.group_controller);
   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.
   ALLOW_UNUSED_LOCAL(ok);
 {%- endif %}
 }
 {%- endfor %}
 
 {#--- ProxyToResponder definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     set message_name =
             "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-     set response_params_struct = method.response_param_struct %}
 {%-     set params_description =
             "%s.%s response"|format(interface.name, method.name) %}
 class {{class_name}}_{{method.name}}_ProxyToResponder
     : public base::RefCountedThreadSafe<
           {{class_name}}_{{method.name}}_ProxyToResponder> {
  public:
   static {{class_name}}::{{method.name}}Callback CreateCallback(
       uint64_t request_id,
       bool is_sync,
       mojo::MessageReceiverWithStatus* responder,
-      scoped_refptr<mojo::internal::MultiplexRouter> router) {
+      scoped_refptr<mojo::AssociatedGroupController>
+          group_controller) {
     scoped_refptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy
         = new {{class_name}}_{{method.name}}_ProxyToResponder(
-            request_id, is_sync, responder, router);
+            request_id, is_sync, responder, group_controller);
     return base::Bind(&{{class_name}}_{{method.name}}_ProxyToResponder::Run,
                       proxy);
   }
 
  private:
   friend class base::RefCountedThreadSafe<
       {{class_name}}_{{method.name}}_ProxyToResponder>;
 
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
       bool is_sync,
       mojo::MessageReceiverWithStatus* responder,
-      scoped_refptr<mojo::internal::MultiplexRouter> router)
+      scoped_refptr<mojo::AssociatedGroupController> group_controller)
       : request_id_(request_id),
         is_sync_(is_sync),
         responder_(responder),
-        serialization_context_(std::move(router)) {
+        serialization_context_(std::move(group_controller)) {
   }
 
   ~{{class_name}}_{{method.name}}_ProxyToResponder() {
 #if DCHECK_IS_ON()
     if (responder_) {
       // Is the Mojo application destroying the callback without running it
       // and without first closing the pipe?
       responder_->DCheckInvalid("The callback passed to "
           "{{class_name}}::{{method.name}}() was never run.");
     }
@@ skipping 90 matching lines @@
               message->mutable_payload());
 
       {{alloc_params(method.param_struct, "params", "message",
           "&serialization_context_", "{{class_name}}::{{method.name}}")|
               indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
               message->has_flag(mojo::internal::kMessageIsSync),
               responder,
-              serialization_context_.router);
+              serialization_context_.group_controller);
       // 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 91 matching lines @@
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}