Added JSON schema compiler support for serialized types

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 141 matching lines @@
     for prop in props:
       if prop.type_ == PropertyType.CHOICES:
         enum_name = self._cpp_type_generator.GetChoicesEnumType(prop)
         c.Append('%s %s_type;' % (enum_name, prop.unix_name))
         c.Append()
 
     for prop in self._cpp_type_generator.ExpandParams(props):
       if prop.description:
         c.Comment(prop.description)
       (c.Append('%s %s;' % (
-          self._cpp_type_generator.GetType(prop, wrap_optional=True),
-          prop.unix_name))
+           self._cpp_type_generator.GetType(prop, wrap_optional=True,
+                                            convert_type=True),
+           prop.unix_name))
         .Append()
       )
     return c
 
   def _GenerateType(self, type_):
     """Generates a struct for a type.
     """
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       c.Sblock('namespace %(classname)s {')
       for function in type_.functions.values():
         (c.Concat(self._GenerateFunction(function))
           .Append()
         )
       c.Eblock('}')
     elif type_.type_ == PropertyType.ARRAY:
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::vector<%(item_type)s> %(classname)s;')
       c.Substitute({'classname': classname, 'item_type':
           self._cpp_type_generator.GetType(type_.item_type,
-                                           wrap_optional=True)})
+                                           wrap_optional=True,
+                                           convert_type=True)})
     elif type_.type_ == PropertyType.STRING:
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::string %(classname)s;')
     else:
       if type_.description:
         c.Comment(type_.description)
       (c.Sblock('struct %(classname)s {')
           .Append('~%(classname)s();')
           .Append('%(classname)s();')
@@ skipping 88 matching lines @@
       elif prop.type_ == PropertyType.ARRAY:
         c.Concat(self._GeneratePropertyStructures([prop.item_type]))
         c.Append()
       elif prop.type_ == PropertyType.CHOICES:
         c.Concat(self._GenerateEnumDeclaration(
             self._cpp_type_generator.GetChoicesEnumType(prop),
             prop,
             [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.GetType(prop)
+        enum_name = self._cpp_type_generator.GetType(prop, convert_type=True)
         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))
         # 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:
@@ skipping 24 matching lines @@
     params = function.params
     c.Concat(self._GeneratePropertyStructures(params))
 
     param_lists = self._cpp_type_generator.GetAllPossibleParameterLists(params)
     for param_list in param_lists:
       declaration_list = []
       for param in param_list:
         if param.description:
           c.Comment(param.description)
         declaration_list.append('const %s' % cpp_util.GetParameterDeclaration(
-            param, self._cpp_type_generator.GetType(param)))
+            param, self._cpp_type_generator.GetType(param, convert_type=True)))
       c.Append('scoped_ptr<base::ListValue> Create(%s);' %
                ', '.join(declaration_list))
     return c
 
   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