New go generator shakedown.

mojom/generators/go/translator/mojom_file.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
 
 // TmplFile contains all of the information needed by the templates to generate
 // the go bindings for one mojom file.
 type TmplFile struct {
         PackageName string
@@ skipping 157 matching lines @@
 
         // IsStruct returns true if the field is a struct.
         IsStruct() bool
 
         // IsUnion returns true if the field is a union.
         IsUnion() bool
 
         // IsEnum returns true if the field is an enum.
         IsEnum() bool
 
+        // IsInterface returns true if the field is an interface or interface request.
+        IsInterface() bool
+
+        // IsInterfaceRequest returns true if the field is an interface request.
+        IsInterfaceRequest() bool
+
         // IsArray returns true if the field is an array.
         IsArray() bool
 
         // IsMap returns true if the field is a map.
         IsMap() bool
 
         // IsNullable returns true if the field is nullable.
         IsNullable() bool
         setNullable(nullable bool)
 
@@ skipping 60 matching lines @@
 }
 
 func (b *baseEncodingInfo) IsUnion() bool {
         return false
 }
 
 func (b *baseEncodingInfo) IsEnum() bool {
         return false
 }
 
+func (b *baseEncodingInfo) IsInterface() bool {
+        return false
+}
+
+func (b *baseEncodingInfo) IsInterfaceRequest() bool {
+        return false
+}
+
 func (b *baseEncodingInfo) IsArray() bool {
         return false
 }
 
 func (b *baseEncodingInfo) IsMap() bool {
         return false
 }
 
 func (b *baseEncodingInfo) ElementEncodingInfo() EncodingInfo {
         panic("Only arrays have elements!")
@@ skipping 19 matching lines @@
 func (b *baseEncodingInfo) GoType() string {
         return b.goType
 }
 
 func (b *baseEncodingInfo) setGoType(goType string) {
         b.goType = goType
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+type baseNullableEncodingInfo struct {
+        baseEncodingInfo
+        nullable bool
+}
+
+func (b *baseNullableEncodingInfo) IsNullable() bool {
+        return b.nullable
+}
+
+func (b *baseNullableEncodingInfo) setNullable(nullable bool) {
+        b.nullable = nullable
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 // basePointerEncodingInfo implements the EncodingInfo for pointer types.
 type basePointerEncodingInfo struct {
-        baseEncodingInfo
-        nullable bool
-}
-
-func (b *basePointerEncodingInfo) IsNullable() bool {
-        return b.nullable
-}
-
-func (b *basePointerEncodingInfo) setNullable(nullable bool) {
-        b.nullable = nullable
+        baseNullableEncodingInfo
 }
 
 func (b *basePointerEncodingInfo) IsPointer() bool {
         return true
 }
 
 func (b *basePointerEncodingInfo) BitSize() uint32 {
         return uint32(64)
 }
 
@@ skipping 38 matching lines @@
         return "WriteString"
 }
 
 func (t *stringTypeEncodingInfo) ReadFunction() string {
         return "ReadString"
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 type handleTypeEncodingInfo struct {
-        baseEncodingInfo
-        nullable     bool
+        baseNullableEncodingInfo
         readFunction string
 }
 
 func (t *handleTypeEncodingInfo) IsHandle() bool {
         return true
 }
 
-func (t *handleTypeEncodingInfo) IsNullable() bool {
-        return t.nullable
-}
-
 func (t *handleTypeEncodingInfo) BitSize() uint32 {
         return 32
 }
 
 func (t *handleTypeEncodingInfo) WriteFunction() string {
         panic("No write function needs to be specified for handles.")
 }
 
 func (t *handleTypeEncodingInfo) ReadFunction() string {
         return t.readFunction
@@ skipping 68 matching lines @@
 }
 
 func (t *structTypeEncodingInfo) ReadFunction() string {
         panic("Structs don't have a read function.")
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // unionTypeEncodingInfo is the EncodingInfo for a union.
 type unionTypeEncodingInfo struct {
-        baseEncodingInfo
+        baseNullableEncodingInfo
         nestedUnion bool
-        nullable    bool
 }
 
 func (t *unionTypeEncodingInfo) BitSize() uint32 {
         if t.nestedUnion {
                 return uint32(64)
         }
         return uint32(128)
 }
 
 func (t *unionTypeEncodingInfo) IsUnion() bool {
         return true
 }
 
 func (t *unionTypeEncodingInfo) IsPointer() bool {
         return t.nestedUnion
 }
 
-func (b *unionTypeEncodingInfo) IsNullable() bool {
-        return b.nullable
-}
-
-func (b *unionTypeEncodingInfo) setNullable(nullable bool) {
-        b.nullable = nullable
-}
-
 func (t *unionTypeEncodingInfo) WriteFunction() string {
         panic("Unions don't have a write function.")
 }
 
 func (t *unionTypeEncodingInfo) ReadFunction() string {
         panic("Unions don't have a read function.")
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 10 matching lines @@
         return true
 }
 
 func (t *enumTypeEncodingInfo) WriteFunction() string {
         panic("Enums don't have a write function.")
 }
 
 func (t *enumTypeEncodingInfo) ReadFunction() string {
         return "ReadInt32"
 }
+
+////////////////////////////////////////////////////////////////////////////////
+
+type interfaceTypeEncodingInfo struct {
+        baseNullableEncodingInfo
+        interfaceRequest bool
+}
+
+func (t *interfaceTypeEncodingInfo) IsInterface() bool {
+        return true
+}
+
+func (t *interfaceTypeEncodingInfo) IsInterfaceRequest() bool {
+        return t.interfaceRequest
+}
+
+func (t *interfaceTypeEncodingInfo) BitSize() uint32 {
+        if t.interfaceRequest {
+                return uint32(32)
+        } else {
+                return uint32(64)
+        }
+}
+
+func (t *interfaceTypeEncodingInfo) WriteFunction() string {
+        if t.interfaceRequest {
+                return "WriteHandle"
+        } else {
+                return "WriteInterface"
+        }
+}
+
+func (t *interfaceTypeEncodingInfo) ReadFunction() string {
+        if t.interfaceRequest {
+                return "ReadMessagePipeHandle"
+        } else {
+                return "ReadInterface"
+        }
+}