Mojom Parser: Populate |serialized_runimte_type_info| field during serialization.

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 (
         "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.
-var EmitLineAndColumnNumbers bool = true
+var emitLineAndColumnNumbers bool = true
+
+// This variable may be set to false in order to omit emitting serialized
+// runtime type info.
+var emitSerializedRuntimeTypeInfo bool = true
 
 // 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)
+}
+
+// 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 and emitSerializedRuntimeTypeInfo.
+// This function is not thread safe because it accesses the global variables
+// emitLineAndColumnNumbers and emitSerializedRuntimeTypeInfo.
+func serialize(d *mojom.MojomDescriptor, debug,
+        emitLineAndColumnNumbersParam, emitSerializedRuntimeTypeInfoParam bool) (bytes []byte, debugString string, err error) {
+        saveEmitLineAndColumnNumbers := emitLineAndColumnNumbers
+        emitLineAndColumnNumbers = emitLineAndColumnNumbersParam
+        saveEmitSerializedRuntimeTypeInfo := emitSerializedRuntimeTypeInfo
+        emitSerializedRuntimeTypeInfo = emitSerializedRuntimeTypeInfoParam
+
         fileGraph := translateDescriptor(d)
         if debug {
                 debugString = myfmt.Sprintf("%#v", fileGraph)
         }
         encoder := bindings.NewEncoder()
         fileGraph.Encode(encoder)
         bytes, _, err = encoder.Data()
+
+        emitLineAndColumnNumbers = saveEmitLineAndColumnNumbers
+        emitSerializedRuntimeTypeInfo = saveEmitSerializedRuntimeTypeInfo
         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{}
 
-        // Add |files| field.
-        fileGraph.Files = make(map[string]mojom_files.MojomFile)
-        for name, file := range d.MojomFilesByName {
-                fileGraph.Files[name] = translateMojomFile(file)
-        }
-
         // Add |resolved_types| field.
         fileGraph.ResolvedTypes = make(map[string]mojom_types.UserDefinedType)
         for key, userDefinedType := range d.TypesByKey {
                 fileGraph.ResolvedTypes[key] = translateUserDefinedType(userDefinedType)
         }
 
         // Add |resolved_values| field.
         fileGraph.ResolvedValues = make(map[string]mojom_types.UserDefinedValue)
         for key, userDefinedValue := range d.ValuesByKey {
                 fileGraph.ResolvedValues[key] = translateUserDefinedValue(userDefinedValue)
         }
 
+        // Add |files| field.
+        fileGraph.Files = make(map[string]mojom_files.MojomFile)
+        for name, file := range d.MojomFilesByName {
+                fileGraph.Files[name] = translateMojomFile(file, &fileGraph)
+        }
+
         return &fileGraph
 }
 
 // translateMojomFile translates from a mojom.MojomFile (the pure Go
 // representation used by the parser) to a mojom_files.MojomFile (the
 // Mojo Go representation used for serialization.)
-func translateMojomFile(f *mojom.MojomFile) (file mojom_files.MojomFile) {
+func translateMojomFile(f *mojom.MojomFile, fileGraph *mojom_files.MojomFileGraph) (file mojom_files.MojomFile) {
         // file_name field
         file.FileName = f.CanonicalFileName
 
         // specified_file_name_field
         file.SpecifiedFileName = &f.SpecifiedFileName
 
         // module_namespace field
         file.ModuleNamespace = &f.ModuleNamespace.Identifier
 
         // attributes field
         if f.Attributes != nil {
                 file.Attributes = new([]mojom_types.Attribute)
                 for _, attr := range f.Attributes.List {
                         *(file.Attributes) = append(*(file.Attributes), translateMojomAttribute(&attr))
                 }
         }
 
         // imports field
         if len(f.Imports) > 0 {
                 file.Imports = new([]string)
                 for _, importName := range f.Imports {
                         *(file.Imports) = append(*(file.Imports), importName.CanonicalFileName)
                 }
         }
 
-        // declared_mojom_objects field...
+        // We will populate a RuntimeTypeInfo structure and then serialize it and
+        // the serialized bytes will form the |serialized_runtime_type_info| field
+        // of the MojomFile.
+        typeInfo := mojom_files.RuntimeTypeInfo{}
+        typeInfo.ServicesByName = make(map[string]mojom_files.ServiceTypeInfo)
+        typeInfo.TypeMap = make(map[string]mojom_types.UserDefinedType)
+
+        // We populate the declared_mojom_objects field
+        // and simultaneously we populate typeInfo.TypeMap.
 
         // Interfaces
         if f.Interfaces != nil && len(f.Interfaces) > 0 {
                 file.DeclaredMojomObjects.Interfaces = new([]string)
                 for _, intrfc := range f.Interfaces {
-                        *(file.DeclaredMojomObjects.Interfaces) = append(*(file.DeclaredMojomObjects.Interfaces), intrfc.TypeKey())
+                        typeKey := intrfc.TypeKey()
+                        *(file.DeclaredMojomObjects.Interfaces) = append(*(file.DeclaredMojomObjects.Interfaces), typeKey)
+
+                        addServiceTypeInfo(intrfc, &typeInfo)
+                        typeInfo.TypeMap[typeKey] = fileGraph.ResolvedTypes[typeKey]
+                        if intrfc.Enums != nil {
+                                // Add embedded enums to typeInfo.TypeMap.
+                                for _, enum := range intrfc.Enums {
+                                        typeKey := enum.TypeKey()
+                                        typeInfo.TypeMap[typeKey] = fileGraph.ResolvedTypes[typeKey]
+                                }
+                        }
                 }
         }
 
         // Structs
         if f.Structs != nil && len(f.Structs) > 0 {
                 file.DeclaredMojomObjects.Structs = new([]string)
                 for _, strct := range f.Structs {
-                        *(file.DeclaredMojomObjects.Structs) = append(*(file.DeclaredMojomObjects.Structs), strct.TypeKey())
+                        typeKey := strct.TypeKey()
+                        *(file.DeclaredMojomObjects.Structs) = append(*(file.DeclaredMojomObjects.Structs), typeKey)
+                        typeInfo.TypeMap[typeKey] = fileGraph.ResolvedTypes[typeKey]
+                        if strct.Enums != nil {
+                                // Add embedded enums to typeInfo.TypeMap.
+                                for _, enum := range strct.Enums {
+                                        typeKey := enum.TypeKey()
+                                        typeInfo.TypeMap[typeKey] = fileGraph.ResolvedTypes[typeKey]
+                                }
+                        }
                 }
         }
 
         // Unions
         if f.Unions != nil && len(f.Unions) > 0 {
                 file.DeclaredMojomObjects.Unions = new([]string)
                 for _, union := range f.Unions {
-                        *(file.DeclaredMojomObjects.Unions) = append(*(file.DeclaredMojomObjects.Unions), union.TypeKey())
+                        typeKey := union.TypeKey()
+                        *(file.DeclaredMojomObjects.Unions) = append(*(file.DeclaredMojomObjects.Unions), typeKey)
+                        typeInfo.TypeMap[typeKey] = fileGraph.ResolvedTypes[typeKey]
                 }
         }
 
         // TopLevelEnums
         if f.Enums != nil && len(f.Enums) > 0 {
                 file.DeclaredMojomObjects.TopLevelEnums = new([]string)
                 for _, enum := range f.Enums {
-                        *(file.DeclaredMojomObjects.TopLevelEnums) = append(*(file.DeclaredMojomObjects.TopLevelEnums), enum.TypeKey())
+                        typeKey := enum.TypeKey()
+                        *(file.DeclaredMojomObjects.TopLevelEnums) = append(*(file.DeclaredMojomObjects.TopLevelEnums), typeKey)
+                        typeInfo.TypeMap[typeKey] = fileGraph.ResolvedTypes[typeKey]
                 }
         }
 
         // TopLevelConstants
         if f.Constants != nil && len(f.Constants) > 0 {
                 file.DeclaredMojomObjects.TopLevelConstants = new([]string)
                 for _, constant := range f.Constants {
                         *(file.DeclaredMojomObjects.TopLevelConstants) = append(*(file.DeclaredMojomObjects.TopLevelConstants), constant.ValueKey())
                 }
         }
 
         // TODO(rudominer) Do we need the EmbeddedEnums and EmbeddedConstants
         // fields in KeysByType. It seems these fields are not currently being
         // used in mojom_translator.py.
 
+        // SerializedRuntimeTypeInfo
+        if emitSerializedRuntimeTypeInfo {
+                encoder := bindings.NewEncoder()
+                typeInfo.Encode(encoder)
+                bytes, _, err := encoder.Data()
+                if err != nil {
+                        panic(fmt.Sprintf("Error while serializing runtimeTypeInfo: %s", err.Error()))
+                }
+                file.SerializedRuntimeTypeInfo = &bytes
+        }
+
         return
 }
 
+// addServiceTypeInfo will add a ServiceTypeInfo to the ServicesByName field of |typeInfo| corresponding
+// to |intrfc| if |intrfc| is a top-level interface, meaning that it has a non-nil service name. In that
+// case this method returns true. Otherwise this method will do nothing and return fals.
+func addServiceTypeInfo(intrfc *mojom.MojomInterface, typeInfo *mojom_files.RuntimeTypeInfo) (isTopLevel bool) {
+        isTopLevel = intrfc.ServiceName != nil
+        if isTopLevel {
+                serviceTypeInfo := mojom_files.ServiceTypeInfo{}
+                serviceTypeInfo.TopLevelInterface = intrfc.TypeKey()
+                serviceTypeInfo.CompleteTypeSet = intrfc.FindReachableTypes()
+                typeInfo.ServicesByName[*intrfc.ServiceName] = serviceTypeInfo
+        }
+        return
+}
+
 // translateUserDefinedType translates from a mojom.UserDefinedType (the pure Go
 // representation used by the parser) to a mojom_types.UserDefinedType (the
 // Mojo Go representation used for serialization.)
 func translateUserDefinedType(t mojom.UserDefinedType) mojom_types.UserDefinedType {
         switch p := t.(type) {
         case *mojom.MojomStruct:
                 return &mojom_types.UserDefinedTypeStructType{translateMojomStruct(p)}
         case *mojom.MojomInterface:
                 return translateMojomInterface(p)
         case *mojom.MojomEnum:
@@ skipping 382 matching lines @@
                         // in a different field.
                 case *mojom.EnumValue:
                 default:
                         declData.ContainerTypeKey = stringPointer(containingType.TypeKey())
                 }
         }
 
         // source_file_info
         declData.SourceFileInfo = new(mojom_types.SourceFileInfo)
         declData.SourceFileInfo.FileName = d.OwningFile().CanonicalFileName
-        if EmitLineAndColumnNumbers {
+        if emitLineAndColumnNumbers {
                 declData.SourceFileInfo.LineNumber = d.LineNumber()
                 declData.SourceFileInfo.ColumnNumber = d.ColumnNumber()
         }
         return &declData
 }
 
 // Returns nil if there are no contained declarations
 func translateContainedDeclarations(container *mojom.NestedDeclarations) *mojom_types.ContainedDeclarations {
         if container.Enums == nil && container.Constants == nil {
                 return nil
@@ skipping 20 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
 }