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 17 matching lines @@
 
     ifndef_name = cpp_util.GenerateIfndefName(self._namespace.source_file_dir,
                                               self._target_namespace)
     (c.Append('#ifndef %s' % ifndef_name)
       .Append('#define %s' % ifndef_name)
       .Append()
       .Append('#include <string>')
       .Append('#include <vector>')
       .Append()
       .Append('#include "base/basictypes.h"')
+      .Append('#include "base/logging.h"')
       .Append('#include "base/memory/linked_ptr.h"')
       .Append('#include "base/memory/scoped_ptr.h"')
       .Append('#include "base/values.h"')
       .Append('#include "tools/json_schema_compiler/any.h"')
       .Append()
     )
 
     c.Concat(self._cpp_type_generator.GetRootNamespaceStart())
     # TODO(calamity): These forward declarations should be #includes to allow
     # $ref types from other files to be used as required params. This requires
@@ skipping 159 matching lines @@
 
       if type_.from_client:
         (c.Comment('Returns a new base::DictionaryValue representing the'
                    ' serialized form of this %s object. Passes '
                    'ownership to caller.' % classname)
           .Append('scoped_ptr<base::DictionaryValue> ToValue() const;')
         )
 
       (c.Eblock()
         .Sblock(' private:')
+          .Concat(self._GeneratePrivatePropertyStructures(
+              type_.properties.values()))
+          .Append()
           .Append('DISALLOW_COPY_AND_ASSIGN(%(classname)s);')
         .Eblock('};')
       )
     c.Substitute({'classname': classname})
     return c
 
   def _GenerateEvent(self, event):
     """Generates the namespaces for an event.
     """
     c = Code()
@@ skipping 69 matching lines @@
         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 _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]))
+        c.Append()
+      elif prop.type_ == PropertyType.CHOICES:
+        # We only need GetChoiceValue() if there is a ToValue() method.
+        if prop.from_client:
+          c.Append('scoped_ptr<base::Value> GetChoiceValue(%s) const;' %

[not at google - send to devlin, 2012/07/19 23:59:53]

static?

+                   cpp_util.GetParameterDeclaration(prop,
+                       self._cpp_type_generator.GetChoicesEnumType(prop)))
+    return c
+
   def _GenerateCreateCallbackArguments(self, function):
     """Generates functions for passing paramaters to a callback.
     """
     c = Code()
     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)))
       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