Add support for constants in the new go generator.

mojom/generators/go/translator/translator.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 translator
 
 import (
         "fmt"
         "log"
         "sort"
 
         "mojom/generated/mojom_files"
         "mojom/generated/mojom_types"
         "mojom/generators/common"
 )
 
 type Translator interface {
         TranslateMojomFile(fileName string) *TmplFile
 }
 
 type translator struct {
         fileGraph *mojom_files.MojomFileGraph
         // goTypeCache maps type keys to go type strings.
-        goTypeCache     map[string]string
-        imports         map[string]string
-        currentFileName string
-        pkgName         string
-        Config          common.GeneratorConfig
+        goTypeCache      map[string]string
+        goConstNameCache map[string]string
+        imports          map[string]string
+        currentFileName  string
+        pkgName          string
+        Config           common.GeneratorConfig
 }
 
 func NewTranslator(fileGraph *mojom_files.MojomFileGraph) (t *translator) {
         t = new(translator)
         t.fileGraph = fileGraph
         t.goTypeCache = map[string]string{}
+        t.goConstNameCache = map[string]string{}
         t.imports = map[string]string{}
         return t
 }
 
 func (t *translator) TranslateMojomFile(fileName string) (tmplFile *TmplFile) {
         t.currentFileName = fileName
         t.imports = map[string]string{}
 
         tmplFile = new(TmplFile)
         file := t.fileGraph.Files[fileName]
@@ skipping 42 matching lines @@
                 file.DeclaredMojomObjects.Interfaces = &[]string{}
         }
         tmplFile.Interfaces = make([]*InterfaceTemplate, len(*file.DeclaredMojomObjects.Interfaces))
         for i, typeKey := range *file.DeclaredMojomObjects.Interfaces {
                 tmplFile.Interfaces[i] = t.translateMojomInterface(typeKey)
                 if len(tmplFile.Interfaces[i].Methods) > 0 {
                         methodDefined = true
                 }
         }
 
+        if file.DeclaredMojomObjects.TopLevelConstants == nil {
+                file.DeclaredMojomObjects.TopLevelConstants = &[]string{}
+        }
+        if file.DeclaredMojomObjects.EmbeddedConstants == nil {
+                file.DeclaredMojomObjects.EmbeddedConstants = &[]string{}
+        }
+        for _, constKey := range *file.DeclaredMojomObjects.TopLevelConstants {
+                c := t.translateDeclaredConstant(constKey)
+                if c != nil {
+                        tmplFile.Constants = append(tmplFile.Constants, c)
+                }
+        }
+        for _, constKey := range *file.DeclaredMojomObjects.EmbeddedConstants {
+                c := t.translateDeclaredConstant(constKey)
+                if c != nil {
+                        tmplFile.Constants = append(tmplFile.Constants, c)
+                }
+        }
+
         tmplFile.Imports = []Import{}
         tmplFile.MojomImports = []string{}
 
         for pkgName, pkgPath := range t.imports {
                 if pkgName != "service_describer" && pkgName != "mojom_types" && pkgPath != "mojo/public/go/system" {
                         tmplFile.MojomImports = append(tmplFile.MojomImports, pkgName)
                 }
         }
 
         if len(tmplFile.Structs) > 0 || len(tmplFile.Unions) > 0 || len(tmplFile.Interfaces) > 0 {
@@ skipping 185 matching lines @@
         m.Params.Name = fmt.Sprintf("%s_Params", m.FullName)
         m.Params.PrivateName = privateName(m.Params.Name)
         if mojomMethod.ResponseParams != nil {
                 m.ResponseParams = t.translateMojomStructObject(*mojomMethod.ResponseParams)
                 m.ResponseParams.Name = fmt.Sprintf("%s_ResponseParams", m.FullName)
                 m.ResponseParams.PrivateName = privateName(m.ResponseParams.Name)
         }
         return m
 }
 
+func (t *translator) translateDeclaredConstant(constKey string) (c *ConstantTemplate) {
+        declaredConstant := t.fileGraph.ResolvedConstants[constKey]
+        resolvedValue := t.resolveConstRef(declaredConstant.Value)
+        if _, ok := resolvedValue.(*mojom_types.ValueBuiltinValue); ok {
+                // There is no way to have a constant NaN, or infinity in go.
+                return nil
+        }
+        c = new(ConstantTemplate)
+        c.Name = t.goConstName(constKey)
+        c.Type = t.translateType(declaredConstant.Type)
+        c.Value = t.translateValue(declaredConstant.Value)
+        return c
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Implements sort.Interface.
 type structFieldSerializationSorter []mojom_types.StructField
 
 func (s structFieldSerializationSorter) Len() int {
         return len(s)
 }
 
 func (s structFieldSerializationSorter) Less(i, j int) bool {
         if s[i].Offset < s[j].Offset {
                 return true
         }
 
         if s[i].Offset == s[j].Offset && s[i].Bit < s[j].Bit {
                 return true
         }
 
         return false
 }
 
 func (s structFieldSerializationSorter) Swap(i, j int) {
         s[i], s[j] = s[j], s[i]
 }