Mojom frontend: Start populating |resolved_concrete_value| field in 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 410 matching lines @@
                 panic(fmt.Sprintf("Unexpected UserDefinedValue type %T", v))
 
         }
 }
 
 func translateUserDefinedConstant(t *mojom.UserDefinedConstant) *mojom_types.UserDefinedValueDeclaredConstant {
         declaredConstant := mojom_types.UserDefinedValueDeclaredConstant{}
         declaredConstant.Value.Type = translateTypeRef(t.DeclaredType())
         declaredConstant.Value.DeclData = *translateDeclarationData(&t.DeclarationData)
         declaredConstant.Value.Value = translateValueRef(t.ValueRef())
-        // TODO(rudominer) implement UserDefinedValue.resolved_concrete_value.
-        // declaredConstant.ResolvedConcreteValue =
-        //     translateConcreteValue(t.ValueRef().ResolvedConcreteValue()))
+        // We set the |resolved_concrete_value| field only in the following situation.
+        // See the comments in mojom_types.mojom.
+        if _, ok := declaredConstant.Value.Value.(*mojom_types.ValueUserValueReference); ok {
+                // If the type of the |value| field is a UserValueReference...
+                userValueRef := t.ValueRef().(*mojom.UserValueRef)
+                if _, ok := userValueRef.ResolvedDeclaredValue().(*mojom.UserDefinedConstant); ok {
+                        // and if that reference resolves to a user-defined constant.
+                        declaredConstant.Value.ResolvedConcreteValue = translateConcreteValue(t.ValueRef().ResolvedConcreteValue())
+                }
+        }
+
         return &declaredConstant
 }
 
 func translateEnumValue(v *mojom.EnumValue) mojom_types.EnumValue {
         enumValue := mojom_types.EnumValue{}
         enumValue.DeclData = translateDeclarationData(&v.DeclarationData)
         enumValue.EnumTypeKey = v.EnumType().TypeKey()
         if v.ValueRef() != nil {
                 enumValue.InitializerValue = translateValueRef(v.ValueRef())
         }
@@ skipping 105 matching lines @@
         switch valueRef := valueRef.(type) {
         case mojom.LiteralValue:
                 return translateLiteralValue(valueRef)
         case *mojom.UserValueRef:
                 return translateUserValueRef(valueRef)
         default:
                 panic(fmt.Sprintf("Unexpected ValueRef type %T", valueRef))
         }
 }
 
+func translateConcreteValue(cv mojom.ConcreteValue) mojom_types.Value {
+        switch cv := cv.(type) {
+        case mojom.LiteralValue:
+                return translateLiteralValue(cv)
+        // NOTE: See the comments at the top of types.go for a discussion of the difference
+        // between a value and a value reference. In this function we are translating a
+        // value, not a value reference. In the case of a LiteralValue or a
+        // BuiltInConstantValue the distinction is immaterial. But in the case of an
+        // enum value the distinction is important. Here we are building and returning
+        // a synthetic mojom_types.UserValueReference to represent the enum value.
+        // It is only the |value_key| field that needs to be populated. It does not
+        // make sense to populate the |identifier| field for example because we
+        // aren't representing any actual occrence in the .mojom file.
+        case *mojom.EnumValue:
+                return &mojom_types.ValueUserValueReference{mojom_types.UserValueReference{
+                        ValueKey: stringPointer(cv.ValueKey())}}
+        case mojom.BuiltInConstantValue:
+                return translateBuiltInConstantValue(cv)
+        default:
+                panic(fmt.Sprintf("Unexpected ConcreteValue type %T", cv))
+        }
+}
+
 func translateLiteralValue(v mojom.LiteralValue) *mojom_types.ValueLiteralValue {
         var lv mojom_types.LiteralValue
         switch v.ValueType() {
         case mojom.SimpleTypeBool:
                 lv = &mojom_types.LiteralValueBoolValue{v.Value().(bool)}
         case mojom.SimpleTypeDouble:
                 lv = &mojom_types.LiteralValueDoubleValue{v.Value().(float64)}
         case mojom.SimpleTypeFloat:
                 lv = &mojom_types.LiteralValueFloatValue{v.Value().(float32)}
         case mojom.SimpleTypeInt8:
@@ skipping 153 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
 }