Mojom parser: Stop populating the complete_typeset field.

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"
@@ skipping 10 matching lines @@
 //////////////////////////////////////////////////
 
 // This variable may be set to false in order to omit emitting line and
 // column numbers.
 var emitLineAndColumnNumbers bool = true
 
 // This variable may be set to false in order to omit emitting serialized
 // runtime type info.
 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)
+        return serialize(d, debug, 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 and emitSerializedRuntimeTypeInfo.
-// This function is not thread safe because it accesses the global variables
-// emitLineAndColumnNumbers and emitSerializedRuntimeTypeInfo.
+// emitLineAndColumnNumbers, 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 bool) (bytes []byte, debugString string, err error) {
+        emitLineAndColumnNumbersParam, 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
         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
         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 162 matching lines @@
 }
 
 // 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_types.RuntimeTypeInfo) (isTopLevel bool) {
         isTopLevel = intrfc.ServiceName != nil
         if isTopLevel {
                 serviceTypeInfo := mojom_types.ServiceTypeInfo{}
                 serviceTypeInfo.TopLevelInterface = intrfc.TypeKey()
-                serviceTypeInfo.CompleteTypeSet = intrfc.FindReachableTypes()
+                if populateCompleteTypeSet {
+                        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) {
@@ skipping 431 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
 }