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_type_macros.tmpl" as mojom_type_macros %}
 
 {%- 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 12 matching lines @@
 }
 
 type {{interface|name}}_Factory interface {
         Create(request {{interface|name}}_Request)
 }
 
 func (f *{{interface|name}}_ServiceFactory) Name() string {
         return {{interface|name(False)}}_Name
 }
 
+func (f *{{interface|name}}_ServiceFactory) ServiceDescription() {{descpkg}}ServiceDescription {
+        return &{{interface|name}}_ServiceDescription{}
+}
+
 func (f *{{interface|name}}_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
         request := {{interface|name}}_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
         f.Delegate.Create(request)
 }
 
 // CreateMessagePipeFor{{interface|name}} creates a message pipe for use with the
 // {{interface|name}} interface with a {{interface|name}}_Request on one end and a {{interface|name}}_Pointer on the other.
 func CreateMessagePipeFor{{interface|name}}() ({{interface|name}}_Request, {{interface|name}}_Pointer) {
         r, p := bindings.CreateMessagePipeForMojoInterface()
         return {{interface|name}}_Request(r), {{interface|name}}_Pointer(p)
@@ skipping 13 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})
 }
 
+{{ mojom_type_macros.writeMojomTypeDef(typepkg, interface, pkg, exported) }}
+
+func (f *{{interface|name}}_Request) ServiceDescription() {{descpkg}}ServiceDescription {
+        return &{{interface|name}}_ServiceDescription{}
+}
+
+
+type {{interface|name}}_ServiceDescription struct{}
+
+func (sd *{{interface|name}}_ServiceDescription) GetTopLevelInterface() (outMojomInterface {{typepkg}}MojomInterface, err error) {
+        return {{interface|mojom_type_identifier}}(), 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 %}