Add enum class support to json_schema_compiler (idl files)

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 cpp_util
 import schema_util
 import util_cc_helper
 from cpp_namespace_environment import CppNamespaceEnvironment
@@ skipping 144 matching lines @@
     for prop in type_.properties.values():
       t = prop.type_
 
       real_t = self._type_helper.FollowRef(t)
       if real_t.property_type == PropertyType.ENUM:
         namespace_prefix = ('%s::' % real_t.namespace.unix_name
                             if real_t.namespace != self._namespace
                             else '')
         items.append('%s(%s%s)' % (prop.unix_name,
                                    namespace_prefix,
-                                   self._type_helper.GetEnumNoneValue(t)))
+                                   self._type_helper.GetEnumNoneValue(real_t)))
       elif prop.optional:
         continue
       elif t.property_type == PropertyType.INTEGER:
         items.append('%s(0)' % prop.unix_name)
       elif t.property_type == PropertyType.DOUBLE:
         items.append('%s(0.0)' % prop.unix_name)
       elif t.property_type == PropertyType.BOOLEAN:
         items.append('%s(false)' % prop.unix_name)
       elif (t.property_type == PropertyType.ANY or
             t.property_type == PropertyType.ARRAY or
@@ skipping 204 matching lines @@
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false')))
       underlying_type = self._type_helper.FollowRef(prop.type_)
       if underlying_type.property_type == PropertyType.ENUM:
         namespace_prefix = ('%s::' % underlying_type.namespace.unix_name
                             if underlying_type.namespace != self._namespace
                             else '')
         (c.Append('} else {')
           .Append('%%(dst)s->%%(name)s = %s%s;' %
              (namespace_prefix,
-              self._type_helper.GetEnumNoneValue(prop.type_))))
+              self._type_helper.GetEnumNoneValue(underlying_type))))
       c.Eblock('}')
     else:
       (c.Sblock(
           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
         .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
         .Append('return false;')
         .Eblock('}')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
       )
@@ skipping 54 matching lines @@
         underlying_type = self._type_helper.FollowRef(prop.type_)
         if underlying_type.property_type == PropertyType.ENUM:
           # Optional enum values are generated with a NONE enum value,
           # potentially from another namespace.
           maybe_namespace = ''
           if underlying_type.namespace != self._namespace:
             maybe_namespace = '%s::' % underlying_type.namespace.unix_name
           c.Sblock('if (%s != %s%s) {' %
               (prop_var,
                maybe_namespace,
-               self._type_helper.GetEnumNoneValue(prop.type_)))
+               self._type_helper.GetEnumNoneValue(underlying_type)))
         else:
           c.Sblock('if (%s.get()) {' % prop_var)
 
       # ANY is a base::Value which is abstract and cannot be a direct member, so
       # it will always be a pointer.
       is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY
       c.Cblock(self._CreateValueFromType(
           'value->SetWithoutPathExpansion("%s", %%s);' % prop.name,
           prop.name,
           prop.type_,
@@ skipping 645 matching lines @@
     underlying_type = self._type_helper.FollowRef(prop.type_)
     if (underlying_type.property_type == PropertyType.ENUM and
         prop.optional):
       namespace_prefix = ('%s::' % underlying_type.namespace.unix_name
                           if underlying_type.namespace != self._namespace
                           else '')
       c.Append('%s->%s = %s%s;' % (
         dst,
         prop.unix_name,
         namespace_prefix,
-        self._type_helper.GetEnumNoneValue(prop.type_)))
+        self._type_helper.GetEnumNoneValue(underlying_type)))
     return c
 
   def _GenerateError(self, body):
     """Generates an error message pertaining to population failure.
 
     E.g 'expected bool, got int'
     """
     c = Code()
     if not self._generate_error_messages:
       return c
     (c.Append('if (error->length())')
       .Append('  error->append(UTF8ToUTF16("; "));')
       .Append('error->append(UTF8ToUTF16(%s));' % body))
     return c
 
   def _GenerateParams(self, params):
     """Builds the parameter list for a function, given an array of parameters.
     """
     if self._generate_error_messages:
       params = list(params) + ['base::string16* error']
     return ', '.join(str(p) for p in params)
 
   def _GenerateArgs(self, args):
     """Builds the argument list for a function, given an array of arguments.
     """
     if self._generate_error_messages:
       args = list(args) + ['error']
     return ', '.join(str(a) for a in args)