Switch to the new go generator in the mojo tree.

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
+        goTypeCache     map[string]string
+        imports         map[string]string
+        currentFileName string
+        Config          common.GeneratorConfig
 }
 
 func NewTranslator(fileGraph *mojom_files.MojomFileGraph) (t *translator) {
         t = new(translator)
         t.fileGraph = fileGraph
         t.goTypeCache = 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]
 
         tmplFile.PackageName = fileNameToPackageName(fileName)
 
         if file.DeclaredMojomObjects.Structs == nil {
                 file.DeclaredMojomObjects.Structs = &[]string{}
         }
         tmplFile.Structs = make([]*StructTemplate, len(*file.DeclaredMojomObjects.Structs))
         for i, typeKey := range *file.DeclaredMojomObjects.Structs {
@@ skipping 31 matching lines @@
         tmplFile.Interfaces = make([]*InterfaceTemplate, len(*file.DeclaredMojomObjects.Interfaces))
         for i, typeKey := range *file.DeclaredMojomObjects.Interfaces {
                 tmplFile.Interfaces[i] = t.translateMojomInterface(typeKey)
         }
 
         tmplFile.Imports = []Import{
                 Import{PackagePath: "mojo/public/go/bindings", PackageName: "bindings"},
                 Import{PackagePath: "fmt", PackageName: "fmt"},
                 Import{PackagePath: "sort", PackageName: "sort"},
         }
+
+        for pkgName, pkgPath := range t.imports {
+                tmplFile.Imports = append(
+                        tmplFile.Imports,
+                        Import{PackagePath: pkgPath, PackageName: pkgName},
+                )
+        }
         return tmplFile
 }
 
 func (t *translator) GetUserDefinedType(typeKey string) (mojomType mojom_types.UserDefinedType) {
         return t.fileGraph.ResolvedTypes[typeKey]
 }
 
 func (t *translator) translateMojomStruct(typeKey string) (m *StructTemplate) {
         m = new(StructTemplate)
         u := t.GetUserDefinedType(typeKey)
@@ skipping 140 matching lines @@
         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]
 }