Added ToJson to JSON schema compiler.

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 any_helper
 import cpp_util
 import model
 import schema_util
@@ skipping 70 matching lines @@
         .Append()
       )
     if self._namespace.events:
       (c.Append('//')
         .Append('// Events')
         .Append('//')
         .Append()
       )
     for event in self._namespace.events.values():
       (c.Concat(self._GenerateCreateCallbackArguments(
-          cpp_util.Classname(event.name), event))
+          cpp_util.Classname(event.name), event, generate_to_json=True))
         .Append()
       )
     (c.Concat(self._cpp_type_generator.GetNamespaceEnd())
       .Concat(self._cpp_type_generator.GetRootNamespaceEnd())
       .Append()
     )
     return c
 
   def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
@@ skipping 570 matching lines @@
 
   def _GenerateReturnCase(self, case_value, return_value):
     """Generates a single return case for a switch block.
     """
     c = Code()
     (c.Append('case %s:' % case_value)
       .Append('  return %s;' % return_value)
     )
     return c
 
-  def _GenerateCreateCallbackArguments(self, function_scope, callback):
+  def _GenerateCreateCallbackArguments(self,
+                                       function_scope,
+                                       callback,
+                                       generate_to_json=False):
     """Generate all functions to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Results::Create
     E.g for event "Baz", generate Baz::Create
 
     function_scope: the function scope path, e.g. Foo::Bar for the function
     Foo::Bar::Baz().
     callback: the Function object we are creating callback arguments for.
+    generate_to_json: Generate a ToJson method.
     """
     c = Code()
     params = callback.params
     expanded_params = self._cpp_type_generator.ExpandParams(params)
     c.Concat(self._GeneratePropertyFunctions(function_scope, expanded_params))
 
     param_lists = self._cpp_type_generator.GetAllPossibleParameterLists(params)
     for param_list in param_lists:
       (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 param_list:
         # We treat this argument as 'required' to avoid wrapping it in a
         # scoped_ptr if it's optional.
         param_copy = param.Copy()
         param_copy.optional = False
         c.Append('create_results->Append(%s);' %
             self._CreateValueFromProperty(param_copy, param_copy.unix_name))
         declaration_list.append("const %s" % cpp_util.GetParameterDeclaration(
             param_copy, self._cpp_type_generator.GetType(param_copy)))
 
       c.Append('return create_results.Pass();')
       c.Eblock('}')
+      if generate_to_json:
+        c.Append()
+        (c.Sblock('std::string %(function_scope)s::'
+                  'ToJson(%(declaration_list)s) {')
+          .Append('scoped_ptr<base::ListValue> create_results = '
+                  'Create(%(param_list)s);')
+          .Append('std::string json;')
+          .Append('base::JSONWriter::Write(create_results.get(), &json);')
+          .Append('return json;')
+        )
+        c.Eblock('}')
+
       c.Substitute({
           'function_scope': function_scope,
-          'declaration_list': ', '.join(declaration_list)
+          'declaration_list': ', '.join(declaration_list),
+          'param_list': ', '.join([param.unix_name for param in param_list])

[not at google - send to devlin, 2012/07/26 02:39:58]

I think if you leave out the [] it becomes a generator and still works, i.e.

join(param.unix_name for param in param_list)

and is probably more efficient because it doesn't involve an intermediate list.

[mitchellwrosen, 2012/07/26 17:38:59]

Done.

       })
 
     return c
 
   def _InitializePropertyToDefault(self, prop, dst):
     """Initialize a model.Property to its default value inside an object.
 
     E.g for optional enum "state", generate dst->state = STATE_NONE;
 
     dst: Type*
@@ skipping 21 matching lines @@
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.ARRAY)
 
   def _IsFundamentalOrFundamentalRef(self, prop):
     """Determines if this property is a Fundamental type or is a ref to a
     Fundamental type.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_.
         is_fundamental)