New go generator shakedown.

mojom/generators/go/templates/interfaces.go

 // Copyright 2016 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.
 
 package templates
 
 import (
         "text/template"
 )
 
 const interfaceTmplText = `
 {{- define "Interface" -}}
 {{$interface := . -}}
 {{ template "InterfaceDecl" $interface }}
 
-{{- range $method := $interface.Methods -}}
+{{- range $method := $interface.Methods}}
 {{ template "Method" $method }}
-{{- end -}}
+{{- end}}
 
-{{- if $interface.ServiceName -}}
+{{- if $interface.ServiceName}}
 {{ template "ServiceDecl" $interface }}
-{{- end -}}
+{{- end}}
 {{- end -}}
 `
 
 const interfaceDeclTmplText = `
 {{- define "InterfaceDecl" -}}
 {{- $interface := . -}}
 {{ template "InterfaceInterfaceDecl" $interface }}
 
 {{ template "InterfaceOtherDecl" $interface }}
 
@@ skipping 61 matching lines @@
 }
 {{- end -}}
 `
 
 const methodTmplText = `
 {{- define "Method" -}}
 {{- $method := . -}}
 
 {{ template "MethodParams" $method }}
 
-{{ template "MethodSignature" $method }}
-
 {{ template "MethodFunction" $method }}
 {{- end -}}
 `
 
 const methodOrdinalsTmplText = `
 {{- define "MethodOrdinals" -}}
 {{- $interface := . -}}
 {{- range $method := $interface.Methods -}}
 const {{$method.FullName}}_Ordinal uint32 = {{$method.Ordinal}}
 {{end -}}
 {{- end -}}
 `
 
 const methodParamsTmplText = `
 {{- define "MethodParams" -}}
 {{- $interface := . -}}
 {{ template "Struct" $interface.Params }}
 
-{{- if $interface.ResponseParams -}}
+{{- if $interface.ResponseParams}}
 {{ template "Struct" $interface.ResponseParams }}
 {{- end -}}
 {{- end -}}
 `
 
 const methodSignatureTmplText = `
 {{- define "MethodSignature" -}}
 {{- $method := . -}}
 {{$method.MethodName}}(
 {{- range $field := $method.Params.Fields -}}
 in{{$field.Name}} {{$field.Type}}, 
 {{- end -}}
 ) (
 {{- if $method.ResponseParams -}}
 {{- range $field := $method.ResponseParams.Fields -}}
 out{{$field.Name}} {{$field.Type}},
 {{- end -}}
 {{- end -}}
 err error)
 {{- end -}}
 `
 
 const methodFuncTmplText = `
 {{- define "MethodFunction" -}}
 {{- $method := . -}}
 func (p *{{$method.Interface.Name}}_Proxy) {{ template "MethodSignature" $method }} {
-        payload := &{{$method.Params}}{
+        payload := &{{$method.Params.Name}}{
 {{range $param := $method.Params.Fields -}}
-                {{$param.Name}},
+                in{{$param.Name}},
 {{end}}
         }
 
         header := bindings.MessageHeader{
                 Type: {{$method.FullName}}_Ordinal,
                 Flags: bindings.MessageExpectsResponseFlag,
 {{- if $method.ResponseParams}}
                 RequestId: p.ids.Count(),
 {{- end}}
         }
         var message *bindings.Message
         if message, err = bindings.EncodeMessage(header, payload); err != nil {
                 err = fmt.Errorf("can't encode request: %v", err.Error())
                 p.Close_Proxy()
                 return
         }
-{{- if $method.ResponseParams}}
+{{if $method.ResponseParams}}
         readResult := <-p.router.AcceptWithResponse(message)
         if err = readResult.Error; err != nil {
                 p.Close_Proxy()
                 return
         }
         if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
                 err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
                         fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
                 }
                 return
@@ skipping 10 matching lines @@
                 return
         }
 {{- range $param := $method.ResponseParams.Fields}}
         out{{$param.Name}} = response.out{{$param.Name}}
 {{- end -}}
 {{- else -}}
         if err = p.router.Accept(message); err != nil {
                 p.Close_Proxy()
                 return
         }
-{{end -}}
+{{end}}
         return
 }
 {{- end -}}
 `
 
 const serviceDeclTmplText = `
 {{- define "ServiceDecl" -}}
 {{- $interface := . -}}
 const {{$interface.PrivateName}}_Name string = "{{$interface.ServiceName}}"
 
@@ skipping 16 matching lines @@
         template.Must(goFileTmpl.Parse(interfaceDeclTmplText))
         template.Must(goFileTmpl.Parse(interfaceInterfaceDeclTmplText))
         template.Must(goFileTmpl.Parse(interfaceOtherDeclTmplText))
         template.Must(goFileTmpl.Parse(serviceDeclTmplText))
         template.Must(goFileTmpl.Parse(methodOrdinalsTmplText))
         template.Must(goFileTmpl.Parse(methodParamsTmplText))
         template.Must(goFileTmpl.Parse(methodSignatureTmplText))
         template.Must(goFileTmpl.Parse(methodFuncTmplText))
         template.Must(goFileTmpl.Parse(methodTmplText))
 }