Add optional schema compiler error messages

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, Type
 import cpp_util
 import schema_util
 
 class HGenerator(object):
   def __init__(self, type_generator, cpp_namespace):
     self._type_generator = type_generator
     self._cpp_namespace = cpp_namespace
 
   def Generate(self, namespace):
     return _Generator(namespace,
                       self._type_generator,
                       self._cpp_namespace).Generate()
 
 class _Generator(object):
   """A .h generator for a namespace.
   """
   def __init__(self, namespace, cpp_type_generator, cpp_namespace):
     self._namespace = namespace
     self._type_helper = cpp_type_generator
     self._cpp_namespace = cpp_namespace
     self._target_namespace = (
         self._type_helper.GetCppNamespaceName(self._namespace))
+    self._generate_error_messages = namespace.compiler_options.get(
+        'generate_error_messages', False)
 
   def Generate(self):
     """Generates a Code object with the .h for a single namespace.
     """
     c = Code()
     (c.Append(cpp_util.CHROMIUM_LICENSE)
       .Append()
       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
       .Append()
     )
@@ skipping 182 matching lines @@
       if type_.description:
         c.Comment(type_.description)
       (c.Sblock('struct %(classname)s {')
           .Append('%(classname)s();')
           .Append('~%(classname)s();')
       )
       if type_.origin.from_json:
         (c.Append()
           .Comment('Populates a %s object from a base::Value. Returns'
                    ' whether |out| was successfully populated.' % classname)
-          .Append('static bool Populate(const base::Value& value, '
-                  '%(classname)s* out);')
+          .Append('static bool Populate(%s);' % self._GenerateParams(
+              ('const base::Value& value', '%s* out' % classname)))
         )
         if is_toplevel:
           (c.Append()
             .Comment('Creates a %s object from a base::Value, or NULL on '
                      'failure.' % classname)
-            .Append('static scoped_ptr<%(classname)s> '
-                        'FromValue(const base::Value& value);')
+            .Append('static scoped_ptr<%s> FromValue(%s);' % (
+                classname, self._GenerateParams(('const base::Value& value',))))
           )
       if type_.origin.from_client:
         value_type = ('base::Value'
                       if type_.property_type is PropertyType.CHOICES else
                       'base::DictionaryValue')
         (c.Append()
           .Comment('Returns a new %s representing the serialized form of this '
                    '%s object.' % (value_type, classname))
           .Append('scoped_ptr<%s> ToValue() const;' % value_type)
         )
@@ skipping 66 matching lines @@
     return c
 
   def _GenerateFunctionParams(self, function):
     """Generates the struct for passing parameters from JSON to a function.
     """
     if not function.params:
       return Code()
 
     c = Code()
     (c.Sblock('struct Params {')
-      .Append('static scoped_ptr<Params> Create(const base::ListValue& args);')
+      .Append('static scoped_ptr<Params> Create(%s);' % self._GenerateParams(
+          ('const base::ListValue& args',)))
       .Append('~Params();')
       .Append()
       .Cblock(self._GenerateTypes(p.type_ for p in function.params))
       .Cblock(self._GenerateFields(function.params))
       .Eblock()
       .Append()
       .Sblock(' private:')
         .Append('Params();')
         .Append()
         .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
@@ skipping 41 matching lines @@
   def _GenerateFunctionResults(self, callback):
     """Generates namespace for passing a function's result back.
     """
     c = Code()
     (c.Append('namespace Results {')
       .Append()
       .Concat(self._GenerateCreateCallbackArguments(callback))
       .Append('}  // namespace Results')
     )
     return c
+
+  def _GenerateParams(self, params):
+    """Builds the parameter list for a function, given an array of parameters.
+    """
+    if self._generate_error_messages:
+      params += ('std::string* error = NULL',)
+    return ', '.join(str(p) for p in params)