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

tools/json_schema_compiler/h_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 cpp_util
 import schema_util
 
 class HGenerator(object):
@@ skipping 117 matching lines @@
     for type_ in self._namespace.types.values():
       ExpandType([], type_)
     return dependency_order
 
   def _GenerateEnumDeclaration(self, enum_name, prop, values):
     """Generate the declaration of a C++ enum for the given property and
     values.
     """
     c = Code()
     c.Sblock('enum %s {' % enum_name)
-    if prop.optional:
-      c.Append(self._cpp_type_generator.GetEnumNoneValue(prop) + ',')
+    c.Append(self._cpp_type_generator.GetEnumNoneValue(prop) + ',')
     for value in values:
       c.Append(self._cpp_type_generator.GetEnumValue(prop, value) + ',')
     (c.Eblock('};')
       .Append()
     )
     return c
 
   def _GenerateFields(self, props):
     """Generates the field declarations when declaring a type.
     """
@@ skipping 36 matching lines @@
           self._cpp_type_generator.GetCompiledType(type_.item_type,
                                                    wrap_optional=True)})
     elif type_.type_ == PropertyType.STRING:
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::string %(classname)s;')
     elif type_.type_ == PropertyType.ENUM:
       if type_.description:
         c.Comment(type_.description)
       c.Sblock('enum %(classname)s {')
+      c.Append('%s,' % self._cpp_type_generator.GetEnumNoneValue(type_))
       for value in type_.enum_values:
-        c.Append('%s_%s,' % (classname.upper(), value.upper()))
+        c.Append('%s,' % self._cpp_type_generator.GetEnumValue(type_, value))
       (c.Eblock('};')
         .Append()
         .Append('scoped_ptr<base::Value> CreateEnumValue(%s %s);' %
                 (classname, classname.lower()))
+        .Append('std::string ToString(%s enum_param);' % classname)
+        .Append('%s From%sString(const std::string& enum_string);' %
+            (classname, classname))
       )
     else:
       if type_.description:
         c.Comment(type_.description)
       (c.Sblock('struct %(classname)s {')
           .Append('~%(classname)s();')
           .Append('%(classname)s();')
           .Append()
           .Concat(self._GeneratePropertyStructures(type_.properties.values()))
           .Concat(self._GenerateFields(type_.properties.values()))
@@ skipping 93 matching lines @@
             [choice.type_.name for choice in prop.choices.values()]))
         c.Concat(self._GeneratePropertyStructures(prop.choices.values()))
       elif prop.type_ == PropertyType.ENUM:
         enum_name = self._cpp_type_generator.GetCompiledType(prop)
         c.Concat(self._GenerateEnumDeclaration(
             enum_name,
             prop,
             prop.enum_values))
         create_enum_value = ('scoped_ptr<base::Value> CreateEnumValue(%s %s);' %
                             (enum_name, prop.unix_name))
+        enum_to_string = 'std::string ToString(%s enum_param);' % enum_name
+        enum_from_string = ('%s From%sString(const std::string& enum_string);' %
+            (enum_name, enum_name))
         # If the property is from the UI then we're in a struct so this function
         # should be static. If it's from the client, then we're just in a
         # namespace so we can't have the static keyword.
         if prop.from_json:
           create_enum_value = 'static ' + create_enum_value
-        c.Append(create_enum_value)
+          enum_to_string = 'static ' + enum_to_string
+          enum_from_string = 'static ' + enum_from_string

[not at google - send to devlin, 2012/09/18 03:55:20]

change to use 'static %s' %...

[cduvall, 2012/09/21 00:39:28]

Done.

+        (c.Append(create_enum_value)
+          .Append(enum_to_string)
+          .Append(enum_from_string))
     return c
 
   def _GeneratePrivatePropertyStructures(self, props):
     """Generate the private structures required by a property such as OBJECT
     classes and enums.
     """
     c = Code()
     for prop in props:
       if prop.type_ == PropertyType.ARRAY:
         c.Concat(self._GeneratePrivatePropertyStructures([prop.item_type]))
@@ skipping 28 matching lines @@
 
   def _GenerateFunctionResults(self, callback):
     """Generates namespace for passing a function's result back.
     """
     c = Code()
     (c.Sblock('namespace Results {')
         .Concat(self._GenerateCreateCallbackArguments(callback))
       .Eblock('};')
     )
     return c