Mojom frontend: Compute, validate and populate struct field version info

mojom/mojom_parser/serialization/serialization.go

 // 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.
 
 package serialization
 
 import (
         "bytes"
         "compress/gzip"
         "encoding/base64"
         "fmt"
         "mojo/public/go/bindings"
         "mojom/mojom_parser/generated/mojom_files"
         "mojom/mojom_parser/generated/mojom_types"
         "mojom/mojom_parser/mojom"
         myfmt "third_party/golang/src/fmt"
 )
 
 //////////////////////////////////////////////////
 /// Mojom Descriptor Serialization
 //////////////////////////////////////////////////
 
 // This variable may be set to false in order to omit emitting line and
-// column numbers.
+// column numbers. This is useful in tests.
 var emitLineAndColumnNumbers bool = true
 
+// This variable may be set to false in order to omit emitting computed
+// packing. This is useful in tests.
+var emitComputedPackingData bool = true
+
 // This variable may be set to false in order to omit emitting serialized
-// runtime type info.
+// runtime type info. This is useful in tests.
 var emitSerializedRuntimeTypeInfo bool = true
 
 // By default we do not populate the complete type set of each top-level interface
 // because doing so is expensive and we are not currently using the the data.
 var populateCompleteTypeSet bool = false
 
 // Serialize serializes the MojomDescriptor into a binary form that is passed to the
 // backend of the compiler in order to invoke the code generators.
 // To do this we use Mojo serialization.
 // If |debug| is true we also return a human-readable representation
 // of the serialized mojom_types.FileGraph.
 // This function is not thread safe.
 func Serialize(d *mojom.MojomDescriptor, debug bool) (bytes []byte, debugString string, err error) {
-        return serialize(d, debug, true, true, false)
+        return serialize(d, debug, true, true, true, false)
 }
 
 // serialize() is a package-private version of the public method Serialize().
 // It is intended for use in tests because it allows setting of the variables
-// emitLineAndColumnNumbers, emitSerializedRuntimeTypeInfo and populateCompleteTypeSet.
+// emitLineAndColumnNumbers, emitComputedPackingData, emitSerializedRuntimeTypeInfo
+// and populateCompleteTypeSet.
 // This function is not thread safe because it sets and accesses these global
 // variables.
 func serialize(d *mojom.MojomDescriptor, debug,
-        emitLineAndColumnNumbersParam, emitSerializedRuntimeTypeInfoParam,
+        emitLineAndColumnNumbersParam, emitComputedPackingDataParam, emitSerializedRuntimeTypeInfoParam,
         populateCompleteTypeSetParam bool) (bytes []byte, debugString string, err error) {
 
         // Save the global state and then set it based on the parameters.
         saveEmitLineAndColumnNumbers := emitLineAndColumnNumbers
         emitLineAndColumnNumbers = emitLineAndColumnNumbersParam
+        saveEmitComputedPackingData := emitComputedPackingData
+        emitComputedPackingData = emitComputedPackingDataParam
         saveEmitSerializedRuntimeTypeInfo := emitSerializedRuntimeTypeInfo
         emitSerializedRuntimeTypeInfo = emitSerializedRuntimeTypeInfoParam
         savePopulateCompleteTypeSet := populateCompleteTypeSet
         populateCompleteTypeSet = populateCompleteTypeSetParam
 
         fileGraph := translateDescriptor(d)
         if debug {
                 debugString = myfmt.Sprintf("%#v", fileGraph)
         }
         encoder := bindings.NewEncoder()
         encoder.SetDeterministic(true)
         fileGraph.Encode(encoder)
         bytes, _, err = encoder.Data()
 
         // Restore the original values of the global state.
         emitLineAndColumnNumbers = saveEmitLineAndColumnNumbers
+        emitComputedPackingData = saveEmitComputedPackingData
         emitSerializedRuntimeTypeInfo = saveEmitSerializedRuntimeTypeInfo
         populateCompleteTypeSet = savePopulateCompleteTypeSet
         return
 }
 
 // translateDescriptor translates from a mojom.MojomDescriptor (the pure Go
 // representation used by the parser) to a mojom_files.MojomFileGraph (the
 // Mojo Go representation used for serialization.)
 func translateDescriptor(d *mojom.MojomDescriptor) *mojom_files.MojomFileGraph {
         fileGraph := mojom_files.MojomFileGraph{}
@@ skipping 200 matching lines @@
 
 func translateMojomStruct(s *mojom.MojomStruct) mojom_types.MojomStruct {
         mojomStruct := mojom_types.MojomStruct{}
         mojomStruct.DeclData = translateDeclarationData(&s.DeclarationData)
         mojomStruct.DeclData.ContainedDeclarations = translateContainedDeclarations(&s.NestedDeclarations)
 
         for _, field := range s.FieldsInOrdinalOrder() {
                 mojomStruct.Fields = append(mojomStruct.Fields, translateStructField(field))
         }
 
-        // TODO(rudominer) Implement VersionInfo.
-        //mojomStruct.Value.VersionInfo = new([]mojom_types.StructVersion)
+        if emitComputedPackingData {
+                versionInfo := s.VersionInfo()
+                mojomStruct.VersionInfo = new([]mojom_types.StructVersion)
+                for _, version := range versionInfo {
+                        (*mojomStruct.VersionInfo) = append(*mojomStruct.VersionInfo,
+                                translateStructVersion(version))
+                }
+        }
 
         return mojomStruct
 }
 
+func translateStructVersion(v mojom.StructVersion) mojom_types.StructVersion {
+        return mojom_types.StructVersion{
+                VersionNumber: v.VersionNumber,
+                NumFields:     v.NumFields,
+                NumBytes:      v.NumBytes,
+        }
+}
+
 func translateStructField(f *mojom.StructField) (field mojom_types.StructField) {
         field.DeclData = translateDeclarationData(&f.DeclarationData)
         field.Type = translateTypeRef(f.FieldType)
         if f.DefaultValue != nil {
                 field.DefaultValue = translateDefaultFieldValue(f.DefaultValue)
         }
-        // TODO(rudominer) Implement field offsets.
-        field.Offset = f.Offset
+        if emitComputedPackingData {
+                // TODO(rudominer) Check the allowed size of offsets. The type used in
+                // mojom_types.mojom might need to be changed.
+                field.Offset = int32(f.Offset())
+                field.Bit = int8(f.Bit())
+                field.MinVersion = f.MinVersion()
+        }
         return
 }
 
 func translateDefaultFieldValue(v mojom.ValueRef) mojom_types.DefaultFieldValue {
         switch v := v.(type) {
         case mojom.LiteralValue:
                 if v.IsDefault() {
                         return &mojom_types.DefaultFieldValueDefaultKeyword{mojom_types.DefaultKeyword{}}
                 }
                 return &mojom_types.DefaultFieldValueValue{translateLiteralValue(v)}
@@ skipping 384 matching lines @@
 
 // stringPointer is a convenience function for creating a pointer to a string whose value
 // is the specified string. It may be used in situations where the compiler will
 // not allow you to take the address of a string value directly, such as the
 // return value of a function. It is necessary to create pointers to strings because
 // that is how the Mojom type |string?| (i.e. nullable string) is represented in
 // in the Mojom Go bindings.
 func stringPointer(s string) *string {
         return &s
 }