JSON Schema Compiler now supports conversion from Choice to base::Value.

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 235 matching lines @@
 
     return c
 
   def _GenerateFunctionParams(self, function):
     """Generates the struct for passing parameters from JSON to a function.
     """
     c = Code()
 
     if function.params:
       (c.Sblock('struct Params {')
-          .Concat(self._GeneratePropertyStructures(function.params))
+          .Concat(self._GeneratePropertyStructures(function.params,
+                                                   from_function=True))
           .Concat(self._GenerateFields(function.params))
           .Append('~Params();')
           .Append()
           .Append('static scoped_ptr<Params> Create('
                   'const base::ListValue& args);')
         .Eblock()
         .Sblock(' private:')
           .Append('Params();')
           .Append()
           .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
         .Eblock('};')
       )
 
     return c
 
-  def _GeneratePropertyStructures(self, props):
+  def _GeneratePropertyStructures(self, props, from_function=False):
     """Generate the structures required by a property such as OBJECT classes
     and enums.
+    If from_function is True if these properties belong to an API Function.

[not at google - send to devlin, 2012/07/18 01:21:35]

You'll want to use from_client not from_function here, a property of the model
(i.e. props). That's what determines whether ToValue is generated.

(from_client means that the data originates on the client; meaning that we'll
want to ToValue it).

[chebert, 2012/07/19 00:56:01]

Done.

     """
     c = Code()
     for prop in props:
       if prop.type_ == PropertyType.OBJECT:
         c.Concat(self._GenerateType(prop))
         c.Append()
       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()))
+        # We only need GetChoiceValue() if there is a ToValue() method.
+        if prop.from_json and not from_function:

[not at google - send to devlin, 2012/07/18 01:21:35]

I think this should all be "prop.from_client"?

[chebert, 2012/07/19 00:56:01]

Done.

+          c.Append('scoped_ptr<base::Value> GetChoiceValue(%s) const;' %

[not at google - send to devlin, 2012/07/18 01:21:35]

Btw this should be generated under private; should be easy enough to add an
entirely different function that does that?

_GeneratePrivatePropertyStructures...

so should CreateEnumValue actually (possible cleanup)

[chebert, 2012/07/19 00:56:01]

Turns out the CreateEnumValue move to private is not quick and easy like the
GetChoiceValue, so I will defer it to a future CL, in keeping with the small-CL
mantra.

On 2012/07/18 01:21:35, kalman wrote:

[not at google - send to devlin, 2012/07/19 01:48:22]

sure thing

+                   cpp_util.GetParameterDeclaration(prop,
+                       self._cpp_type_generator.GetChoicesEnumType(prop)))

[not at google - send to devlin, 2012/07/18 01:21:35]

There is some unfortunate whitespace thing going on in the generated code,
namely:

enum IntegersType {
        INTEGERS_NONE,
        INTEGERS_INTEGER,
        INTEGERS_ARRAY,
      };


      scoped_ptr<base::Value> GetChoiceValue(IntegersType integers) const;
      enum StringsType {
        STRINGS_ARRAY,
        STRINGS_STRING,
      };


      scoped_ptr<base::Value> GetChoiceValue(StringsType strings) const;
      IntegersType integers_type;

(check out previewserver.py)

The private thing might fix it.

[chebert, 2012/07/19 00:56:01]

Done.

       elif prop.type_ == PropertyType.ENUM:
         enum_name = self._cpp_type_generator.GetType(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))
         # 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)
     return c
 
   def _GenerateCreateCallbackArguments(self, function):
     """Generates functions for passing paramaters to a callback.
     """
     c = Code()
     params = function.params
-    c.Concat(self._GeneratePropertyStructures(params))
+    c.Concat(self._GeneratePropertyStructures(params, from_function=True))
 
     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)))
       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