Delete the |complete_type_set| field from mojom_types.mojom

mojom/mojom_tool/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"
@@ skipping 14 matching lines @@
 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. 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, true, false)
+        return serialize(d, debug, true, 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, emitComputedPackingData, emitSerializedRuntimeTypeInfo
-// and populateCompleteTypeSet.
+// emitLineAndColumnNumbers, emitComputedPackingData and emitSerializedRuntimeTypeInfo.
 // This function is not thread safe because it sets and accesses these global
 // variables.
 func serialize(d *mojom.MojomDescriptor, debug,
-        emitLineAndColumnNumbersParam, emitComputedPackingDataParam, emitSerializedRuntimeTypeInfoParam,
-        populateCompleteTypeSetParam bool) (bytes []byte, debugString string, err error) {
+        emitLineAndColumnNumbersParam, emitComputedPackingDataParam,
+        emitSerializedRuntimeTypeInfoParam 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{}
 
         // Add |resolved_types| field.
@@ skipping 53 matching lines @@
                         // If we are in a mode where canonical file names are not being resolved
                         // then emit a null value for |imports| rather than an empty array.
                         file.Imports = nil
                 }
         }
 
         // 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_types.RuntimeTypeInfo{}
-        typeInfo.ServicesByName = make(map[string]mojom_types.ServiceTypeInfo)
+        typeInfo.Services = make(map[string]string)
         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 {
                         typeKey := intrfc.TypeKey()
                         *(file.DeclaredMojomObjects.Interfaces) = append(*(file.DeclaredMojomObjects.Interfaces), typeKey)
 
-                        addServiceTypeInfo(intrfc, &typeInfo)
+                        addServiceName(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]
                                 }
                         }
                 }
         }
@@ skipping 67 matching lines @@
                         panic(fmt.Sprintf("Error while gzipping runtimeTypeInfo: %s", err.Error()))
                 }
                 byteSlice = compressedBytes.Bytes()
                 encoded := base64.StdEncoding.EncodeToString(byteSlice)
                 file.SerializedRuntimeTypeInfo = &encoded
         }
 
         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
+// addServiceName will add the service name of |intrfc| to the |Services| field of |typeInfo|
+// 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_types.RuntimeTypeInfo) (isTopLevel bool) {
+func addServiceName(intrfc *mojom.MojomInterface, typeInfo *mojom_types.RuntimeTypeInfo) (isTopLevel bool) {
         isTopLevel = intrfc.ServiceName != nil
         if isTopLevel {
-                serviceTypeInfo := mojom_types.ServiceTypeInfo{}
-                serviceTypeInfo.TopLevelInterface = intrfc.TypeKey()
-                if populateCompleteTypeSet {
-                        serviceTypeInfo.CompleteTypeSet = intrfc.FindReachableTypes()
-                }
-                typeInfo.ServicesByName[*intrfc.ServiceName] = serviceTypeInfo
+                typeInfo.Services[*intrfc.ServiceName] = intrfc.TypeKey()
         }
         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:
@@ skipping 456 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
 }