Extensions Docs Server: Enum values do not show up if enum is a type

tools/json_schema_compiler/cc_generator.py

 # Copyright (c) 2012 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.
 
 from code import Code
 from model import PropertyType
 import any_helper
 import cpp_util
 import model
 import schema_util
@@ skipping 91 matching lines @@
     """
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       for function in type_.functions.values():
         (c.Concat(
             self._GenerateFunction(
                 cpp_namespace + '::' + cpp_util.Classname(function.name),
                 function))
-          .Append()
-        )
+          .Append())
     elif type_.type_ == PropertyType.OBJECT:
       (c.Concat(self._GeneratePropertyFunctions(
           cpp_namespace, type_.properties.values()))
         .Sblock('%(namespace)s::%(classname)s()')
         .Concat(self._GenerateInitializersAndBody(type_))
         .Eblock('%(namespace)s::~%(classname)s() {}')
-        .Append()
-      )
+        .Append())
       if type_.from_json:
         (c.Concat(self._GenerateTypePopulate(cpp_namespace, type_))
-          .Append()
-        )
+          .Append())
       if type_.from_client:
         (c.Concat(self._GenerateTypeToValue(cpp_namespace, type_))
-          .Append()
-        )
+          .Append())
     elif self._cpp_type_generator.IsEnumOrEnumRef(type_):
-      c.Concat(self._GenerateCreateEnumTypeValue(cpp_namespace, type_))
-      c.Append()
+      (c.Concat(self._GenerateCreateEnumTypeValue(cpp_namespace, type_))
+        .Append()
+        .Concat(self._GenerateEnumFromString(cpp_namespace, type_))
+        .Append()
+        .Concat(self._GenerateEnumToString(cpp_namespace, type_))
+        .Append())
     c.Substitute({'classname': classname, 'namespace': cpp_namespace})
 
     return c
 
   def _GenerateInitializersAndBody(self, type_):
     items = []
     for prop in type_.properties.values():
       if prop.optional:
         continue
 
@@ skipping 70 matching lines @@
     """Generate the code to populate a single property in a type.
 
     src: base::DictionaryValue*
     dst: Type*
     """
     c = Code()
     value_var = prop.unix_name + '_value'
     c.Append('const base::Value* %(value_var)s = NULL;')
     if prop.optional:
       (c.Sblock(
-          'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {'
-        )
+          'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
         .Concat(self._GeneratePopulatePropertyFromValue(
-            prop, value_var, dst, 'false'))
-        .Eblock('}')
-      )
+            prop, value_var, dst, 'false')))
+      if self._cpp_type_generator.IsEnumOrEnumRef(prop):
+        (c.Append('} else {')
+          .Append('%%(dst)s->%%(name)s = %s;' %
+              self._cpp_type_generator.GetEnumNoneValue(prop)))
+      c.Eblock('}')
     else:
       (c.Append(
           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s))')
         .Append('  return false;')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
       )
     c.Append()
-    c.Substitute({'value_var': value_var, 'key': prop.name, 'src': src})
+    c.Substitute({
+      'value_var': value_var,
+      'key': prop.name,
+      'src': src,
+      'dst': dst,
+      'name': prop.unix_name
+    })
     return c
 
   def _GenerateTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes the type into a
     |base::DictionaryValue|.
 
     E.g. for type "Foo" generates Foo::ToValue()
     """
     c = Code()
     (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' %
@@ skipping 88 matching lines @@
       return '%s.DeepCopy()' % self._any_helper.GetValue(prop, var)
     elif prop.type_ == PropertyType.ADDITIONAL_PROPERTIES:
       return '%s.DeepCopy()' % var
     elif prop.type_ == PropertyType.FUNCTION:
       if prop.optional:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return '%sDeepCopy()' % vardot
     elif self._cpp_type_generator.IsEnumOrEnumRef(prop):
-      return 'CreateEnumValue(%s).release()' % var
+      return 'base::Value::CreateStringValue(ToString(%s))' % var
     elif prop.type_ == PropertyType.BINARY:
       if prop.optional:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
               (vardot, vardot))
     elif self._IsArrayOrArrayRef(prop):
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
           self._cpp_type_generator.GetReferencedProperty(prop), var,
@@ skipping 284 matching lines @@
         c.Append('%(dst)s->%(name)s.reset(new std::vector<' + (
           self._cpp_type_generator.GetType(prop.item_type) + '>);'))
         accessor = '->'
       c.Sblock('for (ListValue::const_iterator it = list->begin(); '
                 'it != list->end(); ++it) {')
       self._GenerateStringToEnumConversion(
           c, prop.item_type, '(*it)', 'enum_temp')
       c.Append('%(dst)s->%(name)s' + accessor + 'push_back(enum_temp);')
       c.Eblock('}')
 
-  def _GenerateStringToEnumConversion(self,
-                                      c,
-                                      prop,
-                                      value_var,
-                                      enum_temp):
+  def _GenerateStringToEnumConversion(self, c, prop, value_var, enum_temp):
     """Appends code that converts a string to an enum.
     Leaves failure_value unsubstituted.
 
     c: the code that is appended to.
     prop: the property that the code is populating.
     value_var: the string value that is being converted.
     enum_temp: the name used to store the temporary enum value.
     """
-    (c.Append('%s %s;' % (self._cpp_type_generator.GetCompiledType(prop),
-                          enum_temp))
-      .Append('std::string enum_as_string;')
+    (c.Append('std::string enum_as_string;')
       .Append('if (!%s->GetAsString(&enum_as_string))' % value_var)
       .Append('  return %(failure_value)s;')
-    )
-    for i, enum_value in enumerate(
-          self._cpp_type_generator.GetReferencedProperty(prop).enum_values):
-      (c.Append(
-          ('if' if i == 0 else 'else if') +
-          '(enum_as_string == "%s")' % enum_value)
-        .Append('  ' + enum_temp + ' = %s;' % (
-            self._cpp_type_generator.GetEnumValue(prop, enum_value)))
-      )
-    (c.Append('else')
-      .Append('  return %(failure_value)s;')
-    )
+      .Append('%(type)s %(enum)s = From%(type)sString(enum_as_string);' % {
+        'type': self._cpp_type_generator.GetCompiledType(prop),
+        'enum': enum_temp
+      })
+      .Append('if (%s == %s)' %
+        (enum_temp, self._cpp_type_generator.GetEnumNoneValue(prop)))
+     .Append('  return %(failure_value)s;'))
 
   def _GeneratePropertyFunctions(self, param_namespace, params):
     """Generate the functions for structures generated by a property such as
     CreateEnumValue for ENUMs and Populate/ToValue for Params/Results objects.
     """
     c = Code()
     for param in params:
       if param.type_ == PropertyType.OBJECT:
         c.Concat(self._GenerateType(
             param_namespace + '::' + cpp_util.Classname(param.name),
             param))
         c.Append()
       elif param.type_ == PropertyType.ARRAY:
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, [param.item_type]))
       elif param.type_ == PropertyType.CHOICES:
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, param.choices.values()))
         if param.from_client:
           c.Concat(self._GenerateGetChoiceValue(param_namespace, param))
       elif param.type_ == PropertyType.ENUM:
-        c.Concat(self._GenerateCreateEnumValue(param_namespace, param))
-        c.Append()
+        (c.Concat(self._GenerateCreateEnumValue(param_namespace, param))
+          .Append()
+          .Concat(self._GenerateEnumFromString(param_namespace,
+                                               param,
+                                               use_namespace=True))
+          .Append()
+          .Concat(self._GenerateEnumToString(param_namespace,
+                                             param,
+                                             use_namespace=True))
+          .Append())
     return c
 
   def _GenerateGetChoiceValue(self, cpp_namespace, prop):
     """Generates Get<Type>ChoiceValue() that returns a scoped_ptr<base::Value>
     representing the choice value.
     """
     c = Code()
     (c.Sblock('scoped_ptr<base::Value> '
               '%(cpp_namespace)s::Get%(choice)sChoiceValue() const {')
       .Sblock('switch (%s_type) {' % prop.unix_name)
-    )
-    if prop.optional:
-      c.Concat(self._GenerateReturnCase(
+      .Concat(self._GenerateReturnCase(
           self._cpp_type_generator.GetEnumNoneValue(prop),
-          'scoped_ptr<base::Value>()'))
+          'scoped_ptr<base::Value>()')))
     for choice in self._cpp_type_generator.ExpandParams([prop]):
       c.Concat(self._GenerateReturnCase(
           self._cpp_type_generator.GetEnumValue(prop, choice.type_.name),
           'make_scoped_ptr<base::Value>(%s)' %
               self._CreateValueFromProperty(choice, choice.unix_name)))
     (c.Eblock('}')
-      .Append('NOTREACHED();')
       .Append('return scoped_ptr<base::Value>();')
       .Eblock('}')
       .Append()
       .Substitute({
         'cpp_namespace': cpp_namespace,
         'choice': cpp_util.Classname(prop.name)
       })
     )
     return c
 
   def _GenerateCreateEnumTypeValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the base::StringValue
     representation of an enum type.
     """
     c = Code()
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name))
-    c.Sblock('scoped_ptr<base::Value> CreateEnumValue(%s %s) {' % (
-        classname, classname.lower()))
-    c.Sblock('switch (%s) {' % classname.lower())
+    (c.Sblock('scoped_ptr<base::Value> CreateEnumValue(%s %s) {' %
+        (classname, classname.lower()))
+      .Append('std::string enum_temp = ToString(%s);' % classname.lower())
+      .Append('if (enum_temp.empty())')
+      .Append('  return scoped_ptr<base::Value>();')
+      .Append('return scoped_ptr<base::Value>('
+              'base::Value::CreateStringValue(enum_temp));')
+      .Eblock('}'))
+    return c
 
+  def _GenerateEnumToString(self, cpp_namespace, prop, use_namespace=False):
+    """Generates ToString() which gets the string representation of an enum.
+    """
+    c = Code()
+    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name))
+    if use_namespace:
+      namespace = '%s::' % cpp_namespace
+    else:
+      namespace = ''
+
+    (c.Append('// static')
+      .Sblock('std::string %(namespace)sToString(%(class)s enum_param) {'))
     enum_prop = self._cpp_type_generator.GetReferencedProperty(prop)
+    c.Sblock('switch (enum_param) {')
     for enum_value in enum_prop.enum_values:
       c.Concat(self._GenerateReturnCase(
-          '%s_%s' % (classname.upper(), enum_value.upper()),
-          'scoped_ptr<base::Value>(base::Value::CreateStringValue("%s"))' %
-          enum_value))
-    (c.Eblock('}')
-      .Append('NOTREACHED();')
-      .Append('return scoped_ptr<base::Value>();')
+          self._cpp_type_generator.GetEnumValue(prop, enum_value),
+          '"%s"' % enum_value))
+    (c.Append('case %s:' % self._cpp_type_generator.GetEnumNoneValue(prop))
+      .Append('  return "";')
       .Eblock('}')
-    )
+      .Append('return "";')
+      .Eblock('}')
+      .Substitute({
+        'namespace': namespace,
+        'class': classname
+      }))
+    return c
+
+  def _GenerateEnumFromString(self, cpp_namespace, prop, use_namespace=False):
+    """Generates FromClassNameString() which gets an enum from its string
+    representation.
+    """
+    c = Code()
+    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name))
+    if use_namespace:
+      namespace = '%s::' % cpp_namespace
+    else:
+      namespace = ''
+
+    (c.Append('// static')
+      .Sblock('%(namespace)s%(class)s'
+              ' %(namespace)sFrom%(class)sString('
+              'const std::string& enum_string) {'))
+    enum_prop = self._cpp_type_generator.GetReferencedProperty(prop)
+    for i, enum_value in enumerate(
+          self._cpp_type_generator.GetReferencedProperty(prop).enum_values):
+      # This is broken up into all ifs with no else ifs because we get
+      # "fatal error C1061: compiler limit : blocks nested too deeply"
+      # on Windows.
+      (c.Append('if (enum_string == "%s")' % enum_value)
+        .Append('  return %s;' %
+            self._cpp_type_generator.GetEnumValue(prop, enum_value)))
+    (c.Append('return %s;' %
+        self._cpp_type_generator.GetEnumNoneValue(prop))
+      .Eblock('}')
+      .Substitute({
+        'namespace': namespace,
+        'class': classname
+      }))
     return c
 
   # TODO(chebert): This is basically the same as GenerateCreateEnumTypeValue().
   # The plan is to phase out the old-style enums, and make all enums into REF
   # types.
   def _GenerateCreateEnumValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the base::StringValue
     representation of an enum.
     """
     c = Code()
-    c.Append('// static')
-    c.Sblock('scoped_ptr<base::Value> %(cpp_namespace)s::CreateEnumValue('
+    (c.Append('// static')
+      .Sblock('scoped_ptr<base::Value> %(cpp_namespace)s::CreateEnumValue('
              '%(arg)s) {')
-    c.Sblock('switch (%s) {' % prop.unix_name)
-    if prop.optional:
-      c.Concat(self._GenerateReturnCase(
-          self._cpp_type_generator.GetEnumNoneValue(prop),
-          'scoped_ptr<base::Value>()'))
-    for enum_value in prop.enum_values:
-      c.Concat(self._GenerateReturnCase(
-          self._cpp_type_generator.GetEnumValue(prop, enum_value),
-          'scoped_ptr<base::Value>(base::Value::CreateStringValue("%s"))' %
-          enum_value))
-    (c.Eblock('}')
-      .Append('NOTREACHED();')
-      .Append('return scoped_ptr<base::Value>();')
+      .Append('std::string enum_temp = ToString(%s);' % prop.unix_name)
+      .Append('if (enum_temp.empty())')
+      .Append('  return scoped_ptr<base::Value>();')
+      .Append('return scoped_ptr<base::Value>('
+              'base::Value::CreateStringValue(enum_temp));')
       .Eblock('}')
       .Substitute({
         'cpp_namespace': cpp_namespace,
         'arg': cpp_util.GetParameterDeclaration(
             prop, self._cpp_type_generator.GetType(prop))
-      })
-    )
+      }))
     return c
 
   def _GenerateReturnCase(self, case_value, return_value):
     """Generates a single return case for a switch block.
     """
     c = Code()
     (c.Append('case %s:' % case_value)
       .Append('  return %s;' % return_value)
     )
     return c
@@ skipping 98 matching lines @@
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.ARRAY)
 
   def _IsFundamentalOrFundamentalRef(self, prop):
     """Determines if this property is a Fundamental type or is a ref to a
     Fundamental type.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_.
         is_fundamental)