Generate Mojom Types in Go

mojo/public/tools/bindings/generators/go_templates/interface.tmpl

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 {% import "struct.tmpl" as struct_macros %}
+{% import "mojom_util_macros.tmpl" as util %}
 
 {%- macro declare_params(struct) %}
 {%- for field in struct.fields -%}
         {{field|name(False)}} {{field.kind|go_type}}{% if not loop.last %}, {% endif %}
 {%- endfor %}
 {%- endmacro %}
 
 
 
 {% macro declare_request_params(method) %}
@@ skipping 12 matching lines @@
         bindings.MessageNoFlag
 {%- elif is_response: -%}
         bindings.MessageIsResponseFlag
 {%- else -%}
         bindings.MessageExpectsResponseFlag
 {%- endif -%}
 {%- endmacro -%}
 
 
 
-{% macro define(interface) %}
+{% macro define(interface, descpkg, typepkg, pkg) %}
 type {{interface|name}} interface {
 {% for method in interface.methods %}
         {{method|name}}{{declare_request_params(method)}}
 {% endfor %}
 }
 
 var {{interface|name(False)}}_Name = "{{interface.module.namespace|replace(".","::")}}::{{interface.name}}"
 
 type {{interface|name}}_Request bindings.InterfaceRequest
 
@@ skipping 45 matching lines @@
                 bindings.NewRouter(p.PassMessagePipe(), waiter),
                 bindings.NewCounter(),
         }
 }
 
 func (p *{{interface|name}}_Proxy) Close_Proxy() {
         p.router.Close()
 }
 
 {% for method in interface.methods %}
-{{struct_macros.define(method.param_struct, False)}}
+{{struct_macros.define(method.param_struct, typepkg, pkg, False)}}
 {%-  if method|has_response %}
-{{struct_macros.define(method.response_param_struct, False)}}
+{{struct_macros.define(method.response_param_struct, typepkg, pkg, False)}}
 {%-   endif %}
 func (p *{{interface|name}}_Proxy) {{method|name}}{{declare_request_params(method)}} {
         payload := &{{method.param_struct|name(False)}}{
 {%   for field in (method.param_struct).fields %}
                 {{field|name(False)}},
 {%   endfor %}
         }
         header := bindings.MessageHeader{
                 Type: {{interface|name(False)}}_{{method|name}}_Name,
                 Flags: {{flags(method, False)}},
@@ skipping 46 matching lines @@
 type {{interface|name(False)}}_Stub struct {
         connector *bindings.Connector
         impl {{interface|name}}
 }
 
 func New{{interface|name}}Stub(r {{interface|name}}_Request, impl {{interface|name}}, waiter bindings.AsyncWaiter) *bindings.Stub {
         connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
         return bindings.NewStub(connector, &{{interface|name(False)}}_Stub{connector, impl})
 }
 
+var (
+        interfaceName_{{interface|name}} = "{{interface|name}}"
+{% for method in interface.methods %}
+        interfaceMethodName_{{interface|name}}_{{method|name}} = "{{method|name}}"
+{% endfor %}
+)
+
+func {{util.typeName(interface, typepkg, pkg)}}() {{typepkg}}MojomInterface {
+        responseParamsMap := make(map[string]*{{typepkg}}MojomStruct)
+        _ = responseParamsMap // To avoid the declared but unused compiler error
+{% for method in interface.methods %}
+        {% if method|has_response %}
+        mstruct_{{method|name}} := {{util.typeName(method.response_param_struct, typepkg, pkg)}}()
+        responseParamsMap[interfaceMethodName_{{interface|name}}_{{method|name}}] = &mstruct_{{method|name}}
+        {% endif %}
+{% endfor %}
+        return {{typepkg}}MojomInterface{
+                DeclData: &{{typepkg}}DeclarationData{
+                        ShortName: &interfaceName_{{interface|name}},
+                },
+                Methods: map[uint32]{{typepkg}}MojomMethod{
+{%- for method in interface.methods -%}
+                        {{interface|name(False)}}_{{method|name}}_Name: {{typepkg}}MojomMethod{
+                                DeclData: &{{typepkg}}DeclarationData{
+                                        ShortName: &interfaceMethodName_{{interface|name}}_{{method|name}},
+                                },
+                                Parameters: {{util.typeName(method.param_struct, typepkg, pkg)}}(),
+                                ResponseParams: responseParamsMap[interfaceMethodName_{{interface|name}}_{{method|name}}],
+                        },
+{%- endfor -%}
+                },
+        }
+}
+func (r *{{interface|name}}_Request) Type() {{typepkg}}MojomInterface {
+        return {{util.typeName(interface, typepkg, pkg)}}()
+}
+
+func (r *{{interface|name}}_Request) Desc() map[string]{{typepkg}}UserDefinedType {
+        return Descriptor()
+}
+
+
+
+type {{interface|name}}_ServiceDescription struct{}
+
+func (sd *{{interface|name}}_ServiceDescription) GetTopLevelInterface() (outMojomInterface {{typepkg}}MojomInterface, err error) {
+        return {{util.typeName(interface, typepkg, pkg)}}(), nil
+}
+
+func (sd *{{interface|name}}_ServiceDescription) GetTypeDefinition(inTypeKey string) (outType mojom_types.UserDefinedType, err error) {
+        if udt, ok := Descriptor()[inTypeKey]; ok {
+                return udt, nil
+        }
+        return nil, fmt.Errorf("%s_ServiceDescription does not recognize %s", "{{interface|name}}", inTypeKey)
+}
+
+func (sd *{{interface|name}}_ServiceDescription) GetAllTypeDefinitions() (outDefinitions *map[string]mojom_types.UserDefinedType, err error) {
+        o := Descriptor()
+        return &o, nil
+}
+
+var _ {{descpkg}}ServiceDescription = (*{{interface|name}}_ServiceDescription)(nil)
+
+
 func (s *{{interface|name(False)}}_Stub) Accept(message *bindings.Message) (err error) {
         switch message.Header.Type {
 {% for method in interface.methods %}
         case {{interface|name(False)}}_{{method|name}}_Name:
 {%   if method|has_response %}
                 if message.Header.Flags != bindings.MessageExpectsResponseFlag {
 {%   else %}
                 if message.Header.Flags != bindings.MessageNoFlag {
 {%   endif %}
                         return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
@@ skipping 37 matching lines @@
         default:
                 return &bindings.ValidationError{
                         bindings.MessageHeaderUnknownMethod,
                         fmt.Sprintf("unknown method %v", message.Header.Type),
                 }
         }
         return
 }
 
 {% endmacro %}