Support converting referenced enum array into string.

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
 
@@ skipping 348 matching lines @@
         if underlying_type.property_type == PropertyType.ENUM:
           c.Sblock('if (%s != %s) {' %
               (prop_var,
                self._type_helper.GetEnumNoneValue(prop.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.Append('value->SetWithoutPathExpansion("%s", %s);' % (
+      c.Cblock(self._CreateValueFromType(
+          'value->SetWithoutPathExpansion("%s", %%s);' % prop.name,
           prop.name,
-          self._CreateValueFromType(cpp_namespace,
-                                    prop.type_,
-                                    prop_var,
-                                    is_ptr=is_ptr)))
+          prop.type_,
+          prop_var,
+          is_ptr=is_ptr))
 
       if prop.optional:
         c.Eblock('}')
 
     if type_.additional_properties is not None:
       if type_.additional_properties.property_type == PropertyType.ANY:
         c.Append('value->MergeDictionary(&additional_properties);')
       else:
         # Non-copyable types will be wrapped in a linked_ptr for inclusion in
         # maps, so we need to unwrap them.
         needs_unwrap = (
             not self._type_helper.IsCopyable(type_.additional_properties))
         cpp_type = self._type_helper.GetCppType(type_.additional_properties,
                                                 is_in_container=True)
         (c.Sblock('for (std::map<std::string, %s>::const_iterator it =' %
                       cpp_util.PadForGenerics(cpp_type))
           .Append('       additional_properties.begin();')
           .Append('   it != additional_properties.end(); ++it) {')
-          .Append('value->SetWithoutPathExpansion(it->first, %s);' %
-              self._CreateValueFromType(
-                  cpp_namespace,
-                  type_.additional_properties,
-                  '%sit->second' % ('*' if needs_unwrap else '')))
+          .Cblock(self._CreateValueFromType(
+              'value->SetWithoutPathExpansion(it->first, %s);',
+              type_.additional_properties.name,
+              type_.additional_properties,
+              '%sit->second' % ('*' if needs_unwrap else '')))
           .Eblock('}')
         )
 
     return (c.Append()
              .Append('return value.Pass();')
            .Eblock('}'))
 
   def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes a choice-representing type
     into a base::Value.
     """
     c = Code()
     c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace)
     c.Append('scoped_ptr<base::Value> result;')
     for choice in type_.choices:
       choice_var = 'as_%s' % choice.unix_name
       (c.Sblock('if (%s) {' % choice_var)
           .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' %
                       type_.unix_name)
-          .Append('result.reset(%s);' % self._CreateValueFromType(
-              cpp_namespace,
-              choice,
-              '*%s' % choice_var))
+          .Cblock(self._CreateValueFromType('result.reset(%s);',
+                                            choice.name,
+                                            choice,
+                                            '*%s' % choice_var))
         .Eblock('}')
       )
     (c.Append('DCHECK(result) << "Must set at least one choice for %s";' %
                   type_.unix_name)
       .Append('return result.Pass();')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, function):
@@ skipping 36 matching lines @@
     (c.Append('namespace %s {' % event_namespace)
       .Append()
       .Cblock(self._GenerateEventNameConstant(None, event))
       .Cblock(self._GenerateCreateCallbackArguments(event_namespace,
                                                     None,
                                                     event))
       .Append('}  // namespace %s' % event_namespace)
     )
     return c
 
-  def _CreateValueFromType(self, cpp_namespace, type_, var, is_ptr=False):
+  def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
     """Creates a base::Value given a type. Generated code passes ownership
     to caller.
 
     var: variable or variable*
 
     E.g for std::string, generate new base::StringValue(var)
     """
+    c = Code()
+    underlying_type = self._type_helper.FollowRef(type_)
+    if underlying_type.property_type == PropertyType.ARRAY:
+      # Enums are treated specially because C++ templating thinks that they're
+      # ints, but really they're strings.
+      underlying_item_type = self._type_helper.FollowRef(

[not at google - send to devlin, 2014/05/14 22:52:45]

just |item_type| will be fine.

+          underlying_type.item_type)
+      if underlying_item_type.property_type == PropertyType.ENUM:
+        if is_ptr:
+          vardot = '(%s)->' % var
+        else:
+          vardot = '(%s).' % var

[not at google - send to devlin, 2014/05/14 22:52:45]

how about just:
vardot = '(%s)%s' % (var, '->' if is_ptr else '.')

+
+        maybe_namespace = ''
+        if type_.item_type.property_type == PropertyType.REF:
+          maybe_namespace = '%s::' % underlying_item_type.namespace.unix_name
+
+        enum_list_var = '%s_list' % prop_name

[not at google - send to devlin, 2014/05/14 22:52:45]

try to scope variable declarations inside braces. will require slight
restructuring.

[wjywbs, 2014/05/16 00:47:37]

Do you mean something like this:
enum_array_dict = {
  'vardot': '(%s)%s' % (var, '->' if is_ptr else '.'),
  'maybe_namespace': '',
  'enum_list_var': '%s_list' % prop_name
}

[not at google - send to devlin, 2014/05/16 17:13:47]

I meant the C++ generated code. The python is fine.

[not at google - send to devlin, 2014/05/16 17:36:34]

Because i'm worried that somewhere up in the stack the identifier will conflict
and confuse things. Inside braces it will work.

[wjywbs, 2014/05/16 19:12:23]

Done, but this makes the python code here more complex.

+        (c.Append('std::vector<std::string> %s;' % enum_list_var)
+          .Append('for (typename std::vector<%s>::const_iterator '
+                  'it = %sbegin();'
+              % (self._type_helper.GetCppType(underlying_item_type), vardot))
+          .Sblock('    it != %send(); ++it) {' % vardot)
+          .Append('%s.push_back(%sToString(*it));' % (enum_list_var,
+                                                      maybe_namespace))

[not at google - send to devlin, 2014/05/14 22:52:45]

the reason why this logic was implemented in C++ before, with templates, was to
avoid duplicating code; while templates generate a separate implementation per
type, they at least only do it once. this will generate identical code each time
an array of these need to be serialised.

It might make sense to have an exception here, since it'll be so rare, and it's
pretty complex. but note that.

[not at google - send to devlin, 2014/05/16 17:36:34]

When I said "but note that" I mean add a comment for it.

[wjywbs, 2014/05/16 19:12:23]

I added the comment above in the paragraph of "Enums are treated specially...".

+          .Eblock('}'))
+
+        is_ptr = False
+        var = enum_list_var

[not at google - send to devlin, 2014/05/14 22:52:45]

needs comments around here explaining what is going on

+
+    c.Append(code % self._CreateValueFromTypeInternal(type_, var, is_ptr))

[not at google - send to devlin, 2014/05/14 22:52:45]

why "internal"? this separation seems mostly arbitrary. could you call the
function what it actually does, and add a comment down there?

+    return c
+
+  def _CreateValueFromTypeInternal(self, type_, var, is_ptr):
     underlying_type = self._type_helper.FollowRef(type_)
     if (underlying_type.property_type == PropertyType.CHOICES or
         underlying_type.property_type == PropertyType.OBJECT):
       if is_ptr:
         return '(%s)->ToValue().release()' % var
       else:
         return '(%s).ToValue().release()' % var
     elif (underlying_type.property_type == PropertyType.ANY or
           underlying_type.property_type == PropertyType.FUNCTION):
       if is_ptr:
         vardot = '(%s)->' % var
       else:
         vardot = '(%s).' % var
       return '%sDeepCopy()' % vardot
     elif underlying_type.property_type == PropertyType.ENUM:
       classname = cpp_util.Classname(schema_util.StripNamespace(
           underlying_type.name))
       return 'new base::StringValue(%sToString(%s))' % (classname, var)
     elif underlying_type.property_type == PropertyType.BINARY:
       if is_ptr:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
               (vardot, vardot))
     elif underlying_type.property_type == PropertyType.ARRAY:
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
-          cpp_namespace,
-          underlying_type,
           var,
           is_ptr)
     elif underlying_type.property_type.is_fundamental:
       if is_ptr:
         var = '*%s' % var
       if underlying_type.property_type == PropertyType.STRING:
         return 'new base::StringValue(%s)' % var
       else:
         return 'new base::FundamentalValue(%s)' % var
     else:
@@ skipping 430 matching lines @@
 
     (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s'
                   'Create(%(declaration_list)s) {')
       .Append('scoped_ptr<base::ListValue> create_results('
               'new base::ListValue());')
     )
     declaration_list = []
     for param in params:
       declaration_list.append(cpp_util.GetParameterDeclaration(
           param, self._type_helper.GetCppType(param.type_)))
-      c.Append('create_results->Append(%s);' % self._CreateValueFromType(
-          cpp_namespace,
-          param.type_,
-          param.unix_name))
+      c.Cblock(self._CreateValueFromType('create_results->Append(%s);',
+                                         param.name,
+                                         param.type_,
+                                         param.unix_name))
     c.Append('return create_results.Pass();')
     c.Eblock('}')
     c.Substitute({
         'function_scope': ('%s::' % function_scope) if function_scope else '',
         'declaration_list': ', '.join(declaration_list),
         'param_names': ', '.join(param.unix_name for param in params)
     })
     return c
 
   def _GenerateEventNameConstant(self, function_scope, event):
@@ skipping 40 matching lines @@
     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)