tools/json_schema_compiler/cc_generator.py

   1 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 from code import Code
   6 from model import PropertyType
   7 import cpp_util
   8 import schema_util
   9 import util_cc_helper
  10 from cpp_namespace_environment import CppNamespaceEnvironment
  11
  12 class CCGenerator(object):
  13   def __init__(self, type_generator):
  14     self._type_generator = type_generator
  15
  16   def Generate(self, namespace):
  17     return _Generator(namespace, self._type_generator).Generate()
  18
  19
  20 class _Generator(object):
  21   """A .cc generator for a namespace.
  22   """
  23   def __init__(self, namespace, cpp_type_generator):
  24     assert type(namespace.environment) is CppNamespaceEnvironment
  25     self._namespace = namespace
  26     self._type_helper = cpp_type_generator
  27     self._util_cc_helper = (
  28         util_cc_helper.UtilCCHelper(self._type_helper))
  29     self._generate_error_messages = namespace.compiler_options.get(
  30         'generate_error_messages', False)
  31
  32   def Generate(self):
  33     """Generates a Code object with the .cc for a single namespace.
  34     """
  35     cpp_namespace = cpp_util.GetCppNamespace(
  36         self._namespace.environment.namespace_pattern,
  37         self._namespace.unix_name)
  38
  39     c = Code()
  40     (c.Append(cpp_util.CHROMIUM_LICENSE)
  41       .Append()
  42       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
  43       .Append()
  44       .Append(self._util_cc_helper.GetIncludePath())
  45       .Append('#include "base/logging.h"')
  46       .Append('#include "base/strings/string_number_conversions.h"')
  47       .Append('#include "base/strings/utf_string_conversions.h"')
  48       .Append('#include "%s/%s.h"' %
  49               (self._namespace.source_file_dir, self._namespace.short_filename))
  50       .Append('#include <set>')
  51       .Cblock(self._type_helper.GenerateIncludes(include_soft=True))
  52       .Append()
  53       .Append('using base::UTF8ToUTF16;')
  54       .Append()
  55       .Concat(cpp_util.OpenNamespace(cpp_namespace))
  56     )
  57     if self._namespace.properties:
  58       (c.Append('//')
  59         .Append('// Properties')
  60         .Append('//')
  61         .Append()
  62       )
  63       for property in self._namespace.properties.values():
  64         property_code = self._type_helper.GeneratePropertyValues(
  65             property,
  66             'const %(type)s %(name)s = %(value)s;',
  67             nodoc=True)
  68         if property_code:
  69           c.Cblock(property_code)
  70     if self._namespace.types:
  71       (c.Append('//')
  72         .Append('// Types')
  73         .Append('//')
  74         .Append()
  75         .Cblock(self._GenerateTypes(None, self._namespace.types.values()))
  76       )
  77     if self._namespace.functions:
  78       (c.Append('//')
  79         .Append('// Functions')
  80         .Append('//')
  81         .Append()
  82       )
  83     for function in self._namespace.functions.values():
  84       c.Cblock(self._GenerateFunction(function))
  85     if self._namespace.events:
  86       (c.Append('//')
  87         .Append('// Events')
  88         .Append('//')
  89         .Append()
  90       )
  91       for event in self._namespace.events.values():
  92         c.Cblock(self._GenerateEvent(event))
  93     c.Cblock(cpp_util.CloseNamespace(cpp_namespace))
  94     c.Append()
  95     return c
  96
  97   def _GenerateType(self, cpp_namespace, type_):
  98     """Generates the function definitions for a type.
  99     """
 100     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
 101     c = Code()
 102
 103     if type_.functions:
 104       # Wrap functions within types in the type's namespace.
 105       (c.Append('namespace %s {' % classname)
 106         .Append())
 107       for function in type_.functions.values():
 108         c.Cblock(self._GenerateFunction(function))
 109       c.Append('}  // namespace %s' % classname)
 110     elif type_.property_type == PropertyType.ARRAY:
 111       c.Cblock(self._GenerateType(cpp_namespace, type_.item_type))
 112     elif type_.property_type in (PropertyType.CHOICES,
 113                                  PropertyType.OBJECT):
 114       if cpp_namespace is None:
 115         classname_in_namespace = classname
 116       else:
 117         classname_in_namespace = '%s::%s' % (cpp_namespace, classname)
 118
 119       if type_.property_type == PropertyType.OBJECT:
 120         c.Cblock(self._GeneratePropertyFunctions(classname_in_namespace,
 121                                                  type_.properties.values()))
 122       else:
 123         c.Cblock(self._GenerateTypes(classname_in_namespace, type_.choices))
 124
 125       (c.Append('%s::%s()' % (classname_in_namespace, classname))
 126         .Cblock(self._GenerateInitializersAndBody(type_))
 127         .Append('%s::~%s() {}' % (classname_in_namespace, classname))
 128         .Append()
 129       )
 130       if type_.origin.from_json:
 131         c.Cblock(self._GenerateTypePopulate(classname_in_namespace, type_))
 132         if cpp_namespace is None:  # only generate for top-level types
 133           c.Cblock(self._GenerateTypeFromValue(classname_in_namespace, type_))
 134       if type_.origin.from_client:
 135         c.Cblock(self._GenerateTypeToValue(classname_in_namespace, type_))
 136     elif type_.property_type == PropertyType.ENUM:
 137       (c.Cblock(self._GenerateEnumToString(cpp_namespace, type_))
 138         .Cblock(self._GenerateEnumFromString(cpp_namespace, type_))
 139       )
 140
 141     return c
 142
 143   def _GenerateInitializersAndBody(self, type_):
 144     items = []
 145     for prop in type_.properties.values():
 146       t = prop.type_
 147
 148       real_t = self._type_helper.FollowRef(t)
 149       if real_t.property_type == PropertyType.ENUM:
 150         items.append('%s(%s)' % (
 151             prop.unix_name,
 152             self._type_helper.GetEnumNoneValue(t)))
 153       elif prop.optional:
 154         continue
 155       elif t.property_type == PropertyType.INTEGER:
 156         items.append('%s(0)' % prop.unix_name)
 157       elif t.property_type == PropertyType.DOUBLE:
 158         items.append('%s(0.0)' % prop.unix_name)
 159       elif t.property_type == PropertyType.BOOLEAN:
 160         items.append('%s(false)' % prop.unix_name)
 161       elif (t.property_type == PropertyType.ANY or
 162             t.property_type == PropertyType.ARRAY or
 163             t.property_type == PropertyType.BINARY or  # mapped to std::string
 164             t.property_type == PropertyType.CHOICES or
 165             t.property_type == PropertyType.OBJECT or
 166             t.property_type == PropertyType.FUNCTION or
 167             t.property_type == PropertyType.REF or
 168             t.property_type == PropertyType.STRING):
 169         # TODO(miket): It would be nice to initialize CHOICES, but we
 170         # don't presently have the semantics to indicate which one of a set
 171         # should be the default.
 172         continue
 173       else:
 174         raise TypeError(t)
 175
 176     if items:
 177       s = ': %s' % (', '.join(items))
 178     else:
 179       s = ''
 180     s = s + ' {}'
 181     return Code().Append(s)
 182
 183   def _GenerateTypePopulate(self, cpp_namespace, type_):
 184     """Generates the function for populating a type given a pointer to it.
 185
 186     E.g for type "Foo", generates Foo::Populate()
 187     """
 188     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
 189     c = Code()
 190     (c.Append('// static')
 191       .Append('bool %(namespace)s::Populate(')
 192       .Sblock('    %s) {' % self._GenerateParams(
 193           ('const base::Value& value', '%(name)s* out'))))
 194
 195     if self._generate_error_messages:
 196       c.Append('DCHECK(error);')
 197
 198     if type_.property_type == PropertyType.CHOICES:
 199       for choice in type_.choices:
 200         (c.Sblock('if (%s) {' % self._GenerateValueIsTypeExpression('value',
 201                                                                     choice))
 202             .Concat(self._GeneratePopulateVariableFromValue(
 203                 choice,
 204                 '(&value)',
 205                 'out->as_%s' % choice.unix_name,
 206                 'false',
 207                 is_ptr=True))
 208             .Append('return true;')
 209           .Eblock('}')
 210         )
 211       (c.Concat(self._GenerateError(
 212           '"expected %s, got " +  %s' %
 213               (" or ".join(choice.name for choice in type_.choices),
 214               self._util_cc_helper.GetValueTypeString('value'))))
 215         .Append('return false;'))
 216     elif type_.property_type == PropertyType.OBJECT:
 217       (c.Sblock('if (!value.IsType(base::Value::TYPE_DICTIONARY)) {')
 218         .Concat(self._GenerateError(
 219           '"expected dictionary, got " + ' +
 220           self._util_cc_helper.GetValueTypeString('value')))
 221         .Append('return false;')
 222         .Eblock('}'))
 223
 224       if type_.properties or type_.additional_properties is not None:
 225         c.Append('const base::DictionaryValue* dict = '
 226                      'static_cast<const base::DictionaryValue*>(&value);')
 227         if self._generate_error_messages:
 228             c.Append('std::set<std::string> keys;')
 229       for prop in type_.properties.itervalues():
 230         c.Concat(self._InitializePropertyToDefault(prop, 'out'))
 231       for prop in type_.properties.itervalues():
 232         if self._generate_error_messages:
 233           c.Append('keys.insert("%s");' % (prop.name))
 234         c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out'))
 235       # Check for extra values.
 236       if self._generate_error_messages:
 237         (c.Sblock('for (base::DictionaryValue::Iterator it(*dict); '
 238                        '!it.IsAtEnd(); it.Advance()) {')
 239           .Sblock('if (!keys.count(it.key())) {')
 240           .Concat(self._GenerateError('"found unexpected key \'" + '
 241                                           'it.key() + "\'"'))
 242           .Eblock('}')
 243           .Eblock('}')
 244         )
 245       if type_.additional_properties is not None:
 246         if type_.additional_properties.property_type == PropertyType.ANY:
 247           c.Append('out->additional_properties.MergeDictionary(dict);')
 248         else:
 249           cpp_type = self._type_helper.GetCppType(type_.additional_properties,
 250                                                   is_in_container=True)
 251           (c.Append('for (base::DictionaryValue::Iterator it(*dict);')
 252             .Sblock('     !it.IsAtEnd(); it.Advance()) {')
 253               .Append('%s tmp;' % cpp_type)
 254               .Concat(self._GeneratePopulateVariableFromValue(
 255                   type_.additional_properties,
 256                   '(&it.value())',
 257                   'tmp',
 258                   'false'))
 259               .Append('out->additional_properties[it.key()] = tmp;')
 260             .Eblock('}')
 261           )
 262       c.Append('return true;')
 263     (c.Eblock('}')
 264       .Substitute({'namespace': cpp_namespace, 'name': classname}))
 265     return c
 266
 267   def _GenerateValueIsTypeExpression(self, var, type_):
 268     real_type = self._type_helper.FollowRef(type_)
 269     if real_type.property_type is PropertyType.CHOICES:
 270       return '(%s)' % ' || '.join(self._GenerateValueIsTypeExpression(var,
 271                                                                       choice)
 272                                   for choice in real_type.choices)
 273     return '%s.IsType(%s)' % (var, cpp_util.GetValueType(real_type))
 274
 275   def _GenerateTypePopulateProperty(self, prop, src, dst):
 276     """Generate the code to populate a single property in a type.
 277
 278     src: base::DictionaryValue*
 279     dst: Type*
 280     """
 281     c = Code()
 282     value_var = prop.unix_name + '_value'
 283     c.Append('const base::Value* %(value_var)s = NULL;')
 284     if prop.optional:
 285       (c.Sblock(
 286           'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
 287         .Concat(self._GeneratePopulatePropertyFromValue(
 288             prop, value_var, dst, 'false')))
 289       underlying_type = self._type_helper.FollowRef(prop.type_)
 290       if underlying_type.property_type == PropertyType.ENUM:
 291         (c.Append('} else {')
 292           .Append('%%(dst)s->%%(name)s = %s;' %
 293               self._type_helper.GetEnumNoneValue(prop.type_)))
 294       c.Eblock('}')
 295     else:
 296       (c.Sblock(
 297           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
 298         .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
 299         .Append('return false;')
 300         .Eblock('}')
 301         .Concat(self._GeneratePopulatePropertyFromValue(
 302             prop, value_var, dst, 'false'))
 303       )
 304     c.Append()
 305     c.Substitute({
 306       'value_var': value_var,
 307       'key': prop.name,
 308       'src': src,
 309       'dst': dst,
 310       'name': prop.unix_name
 311     })
 312     return c
 313
 314   def _GenerateTypeFromValue(self, cpp_namespace, type_):
 315     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
 316     c = Code()
 317     (c.Append('// static')
 318       .Append('scoped_ptr<%s> %s::FromValue(%s) {' % (classname,
 319         cpp_namespace, self._GenerateParams(('const base::Value& value',))))
 320     )
 321     if self._generate_error_messages:
 322       c.Append('DCHECK(error);')
 323     (c.Append('  scoped_ptr<%s> out(new %s());' % (classname, classname))
 324       .Append('  if (!Populate(%s))' % self._GenerateArgs(
 325           ('value', 'out.get()')))
 326       .Append('    return scoped_ptr<%s>();' % classname)
 327       .Append('  return out.Pass();')
 328       .Append('}')
 329     )
 330     return c
 331
 332   def _GenerateTypeToValue(self, cpp_namespace, type_):
 333     """Generates a function that serializes the type into a base::Value.
 334     E.g. for type "Foo" generates Foo::ToValue()
 335     """
 336     if type_.property_type == PropertyType.OBJECT:
 337       return self._GenerateObjectTypeToValue(cpp_namespace, type_)
 338     elif type_.property_type == PropertyType.CHOICES:
 339       return self._GenerateChoiceTypeToValue(cpp_namespace, type_)
 340     else:
 341       raise ValueError("Unsupported property type %s" % type_.type_)
 342
 343   def _GenerateObjectTypeToValue(self, cpp_namespace, type_):
 344     """Generates a function that serializes an object-representing type
 345     into a base::DictionaryValue.
 346     """
 347     c = Code()
 348     (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' %
 349           cpp_namespace)
 350         .Append('scoped_ptr<base::DictionaryValue> value('
 351                     'new base::DictionaryValue());')
 352         .Append()
 353     )
 354
 355     for prop in type_.properties.values():
 356       prop_var = 'this->%s' % prop.unix_name
 357       if prop.optional:
 358         # Optional enum values are generated with a NONE enum value.
 359         underlying_type = self._type_helper.FollowRef(prop.type_)
 360         if underlying_type.property_type == PropertyType.ENUM:
 361           c.Sblock('if (%s != %s) {' %
 362               (prop_var,
 363                self._type_helper.GetEnumNoneValue(prop.type_)))
 364         else:
 365           c.Sblock('if (%s.get()) {' % prop_var)
 366
 367       # ANY is a base::Value which is abstract and cannot be a direct member, so
 368       # it will always be a pointer.
 369       is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY
 370       c.Cblock(self._CreateValueFromType(
 371           'value->SetWithoutPathExpansion("%s", %%s);' % prop.name,
 372           prop.name,
 373           prop.type_,
 374           prop_var,
 375           is_ptr=is_ptr))
 376
 377       if prop.optional:
 378         c.Eblock('}')
 379
 380     if type_.additional_properties is not None:
 381       if type_.additional_properties.property_type == PropertyType.ANY:
 382         c.Append('value->MergeDictionary(&additional_properties);')
 383       else:
 384         # Non-copyable types will be wrapped in a linked_ptr for inclusion in
 385         # maps, so we need to unwrap them.
 386         needs_unwrap = (
 387             not self._type_helper.IsCopyable(type_.additional_properties))
 388         cpp_type = self._type_helper.GetCppType(type_.additional_properties,
 389                                                 is_in_container=True)
 390         (c.Sblock('for (std::map<std::string, %s>::const_iterator it =' %
 391                       cpp_util.PadForGenerics(cpp_type))
 392           .Append('       additional_properties.begin();')
 393           .Append('   it != additional_properties.end(); ++it) {')
 394           .Cblock(self._CreateValueFromType(
 395               'value->SetWithoutPathExpansion(it->first, %s);',
 396               type_.additional_properties.name,
 397               type_.additional_properties,
 398               '%sit->second' % ('*' if needs_unwrap else '')))
 399           .Eblock('}')
 400         )
 401
 402     return (c.Append()
 403              .Append('return value.Pass();')
 404            .Eblock('}'))
 405
 406   def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
 407     """Generates a function that serializes a choice-representing type
 408     into a base::Value.
 409     """
 410     c = Code()
 411     c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace)
 412     c.Append('scoped_ptr<base::Value> result;')
 413     for choice in type_.choices:
 414       choice_var = 'as_%s' % choice.unix_name
 415       (c.Sblock('if (%s) {' % choice_var)
 416           .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' %
 417                       type_.unix_name)
 418           .Cblock(self._CreateValueFromType('result.reset(%s);',
 419                                             choice.name,
 420                                             choice,
 421                                             '*%s' % choice_var))
 422         .Eblock('}')
 423       )
 424     (c.Append('DCHECK(result) << "Must set at least one choice for %s";' %
 425                   type_.unix_name)
 426       .Append('return result.Pass();')
 427       .Eblock('}')
 428     )
 429     return c
 430
 431   def _GenerateFunction(self, function):
 432     """Generates the definitions for function structs.
 433     """
 434     c = Code()
 435
 436     # TODO(kalman): use function.unix_name not Classname.
 437     function_namespace = cpp_util.Classname(function.name)
 438     # Windows has a #define for SendMessage, so to avoid any issues, we need
 439     # to not use the name.
 440     if function_namespace == 'SendMessage':
 441       function_namespace = 'PassMessage'
 442     (c.Append('namespace %s {' % function_namespace)
 443       .Append()
 444     )
 445
 446     # Params::Populate function
 447     if function.params:
 448       c.Concat(self._GeneratePropertyFunctions('Params', function.params))
 449       (c.Append('Params::Params() {}')
 450         .Append('Params::~Params() {}')
 451         .Append()
 452         .Cblock(self._GenerateFunctionParamsCreate(function))
 453       )
 454
 455     # Results::Create function
 456     if function.callback:
 457       c.Concat(self._GenerateCreateCallbackArguments(function_namespace,
 458                                                      'Results',
 459                                                      function.callback))
 460
 461     c.Append('}  // namespace %s' % function_namespace)
 462     return c
 463
 464   def _GenerateEvent(self, event):
 465     # TODO(kalman): use event.unix_name not Classname.
 466     c = Code()
 467     event_namespace = cpp_util.Classname(event.name)
 468     (c.Append('namespace %s {' % event_namespace)
 469       .Append()
 470       .Cblock(self._GenerateEventNameConstant(None, event))
 471       .Cblock(self._GenerateCreateCallbackArguments(event_namespace,
 472                                                     None,
 473                                                     event))
 474       .Append('}  // namespace %s' % event_namespace)
 475     )
 476     return c
 477
 478   def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
 479     """Creates a base::Value given a type. Generated code passes ownership
 480     to caller.
 481
 482     var: variable or variable*
 483
 484     E.g for std::string, generate new base::StringValue(var)
 485     """
 486     c = Code()
 487     underlying_type = self._type_helper.FollowRef(type_)
 488     if underlying_type.property_type == PropertyType.ARRAY:
 489       # Enums are treated specially because C++ templating thinks that they're
 490       # ints, but really they're strings. So we create a vector of strings and
 491       # populate it with the names of the enum in the array. The |ToString|
 492       # function of the enum can be in another namespace when the enum is
 493       # referenced. Templates can not be used here because C++ templating does
 494       # not support passing a namespace as an argument.
 495       item_type = self._type_helper.FollowRef(underlying_type.item_type)
 496       if item_type.property_type == PropertyType.ENUM:
 497         vardot = '(%s)%s' % (var, '->' if is_ptr else '.')
 498
 499         maybe_namespace = ''
 500         if type_.item_type.property_type == PropertyType.REF:
 501           maybe_namespace = '%s::' % item_type.namespace.unix_name
 502
 503         enum_list_var = '%s_list' % prop_name
 504         # Scope the std::vector variable declaration inside braces.
 505         (c.Sblock('{')
 506           .Append('std::vector<std::string> %s;' % enum_list_var)
 507           .Append('for (std::vector<%s>::const_iterator it = %sbegin();'
 508               % (self._type_helper.GetCppType(item_type), vardot))
 509           .Sblock('    it != %send(); ++it) {' % vardot)
 510           .Append('%s.push_back(%sToString(*it));' % (enum_list_var,
 511                                                       maybe_namespace))
 512           .Eblock('}'))
 513
 514         # Because the std::vector above is always created for both required and
 515         # optional enum arrays, |is_ptr| is set to false and uses the
 516         # std::vector to create the values.
 517         (c.Append(code %
 518             self._GenerateCreateValueFromType(type_, enum_list_var, False))
 519           .Eblock('}'))
 520         return c
 521
 522     c.Append(code % self._GenerateCreateValueFromType(type_, var, is_ptr))
 523     return c
 524
 525   def _GenerateCreateValueFromType(self, type_, var, is_ptr):
 526     """Generates the statement to create a base::Value given a type.
 527
 528     type_:  The type of the values being converted.
 529     var:    The name of the variable.
 530     is_ptr: Whether |type_| is optional.
 531     """
 532     underlying_type = self._type_helper.FollowRef(type_)
 533     if (underlying_type.property_type == PropertyType.CHOICES or
 534         underlying_type.property_type == PropertyType.OBJECT):
 535       if is_ptr:
 536         return '(%s)->ToValue().release()' % var
 537       else:
 538         return '(%s).ToValue().release()' % var
 539     elif (underlying_type.property_type == PropertyType.ANY or
 540           underlying_type.property_type == PropertyType.FUNCTION):
 541       if is_ptr:
 542         vardot = '(%s)->' % var
 543       else:
 544         vardot = '(%s).' % var
 545       return '%sDeepCopy()' % vardot
 546     elif underlying_type.property_type == PropertyType.ENUM:
 547       maybe_namespace = ''
 548       if type_.property_type == PropertyType.REF:
 549         maybe_namespace = '%s::' % underlying_type.namespace.unix_name
 550       return 'new base::StringValue(%sToString(%s))' % (maybe_namespace, var)
 551     elif underlying_type.property_type == PropertyType.BINARY:
 552       if is_ptr:
 553         vardot = var + '->'
 554       else:
 555         vardot = var + '.'
 556       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
 557               (vardot, vardot))
 558     elif underlying_type.property_type == PropertyType.ARRAY:
 559       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
 560           var,
 561           is_ptr)
 562     elif underlying_type.property_type.is_fundamental:
 563       if is_ptr:
 564         var = '*%s' % var
 565       if underlying_type.property_type == PropertyType.STRING:
 566         return 'new base::StringValue(%s)' % var
 567       else:
 568         return 'new base::FundamentalValue(%s)' % var
 569     else:
 570       raise NotImplementedError('Conversion of %s to base::Value not '
 571                                 'implemented' % repr(type_.type_))
 572
 573   def _GenerateParamsCheck(self, function, var):
 574     """Generates a check for the correct number of arguments when creating
 575     Params.
 576     """
 577     c = Code()
 578     num_required = 0
 579     for param in function.params:
 580       if not param.optional:
 581         num_required += 1
 582     if num_required == len(function.params):
 583       c.Sblock('if (%(var)s.GetSize() != %(total)d) {')
 584     elif not num_required:
 585       c.Sblock('if (%(var)s.GetSize() > %(total)d) {')
 586     else:
 587       c.Sblock('if (%(var)s.GetSize() < %(required)d'
 588           ' || %(var)s.GetSize() > %(total)d) {')
 589     (c.Concat(self._GenerateError(
 590         '"expected %%(total)d arguments, got " '
 591         '+ base::IntToString(%%(var)s.GetSize())'))
 592       .Append('return scoped_ptr<Params>();')
 593       .Eblock('}')
 594       .Substitute({
 595         'var': var,
 596         'required': num_required,
 597         'total': len(function.params),
 598     }))
 599     return c
 600
 601   def _GenerateFunctionParamsCreate(self, function):
 602     """Generate function to create an instance of Params. The generated
 603     function takes a base::ListValue of arguments.
 604
 605     E.g for function "Bar", generate Bar::Params::Create()
 606     """
 607     c = Code()
 608     (c.Append('// static')
 609       .Sblock('scoped_ptr<Params> Params::Create(%s) {' % self._GenerateParams(
 610         ['const base::ListValue& args']))
 611     )
 612     if self._generate_error_messages:
 613       c.Append('DCHECK(error);')
 614     (c.Concat(self._GenerateParamsCheck(function, 'args'))
 615       .Append('scoped_ptr<Params> params(new Params());')
 616     )
 617
 618     for param in function.params:
 619       c.Concat(self._InitializePropertyToDefault(param, 'params'))
 620
 621     for i, param in enumerate(function.params):
 622       # Any failure will cause this function to return. If any argument is
 623       # incorrect or missing, those following it are not processed. Note that
 624       # for optional arguments, we allow missing arguments and proceed because
 625       # there may be other arguments following it.
 626       failure_value = 'scoped_ptr<Params>()'
 627       c.Append()
 628       value_var = param.unix_name + '_value'
 629       (c.Append('const base::Value* %(value_var)s = NULL;')
 630         .Append('if (args.Get(%(i)s, &%(value_var)s) &&')
 631         .Sblock('    !%(value_var)s->IsType(base::Value::TYPE_NULL)) {')
 632         .Concat(self._GeneratePopulatePropertyFromValue(
 633             param, value_var, 'params', failure_value))
 634         .Eblock('}')
 635       )
 636       if not param.optional:
 637         (c.Sblock('else {')
 638           .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
 639           .Append('return %s;' % failure_value)
 640           .Eblock('}'))
 641       c.Substitute({'value_var': value_var, 'i': i, 'key': param.name})
 642     (c.Append()
 643       .Append('return params.Pass();')
 644       .Eblock('}')
 645       .Append()
 646     )
 647
 648     return c
 649
 650   def _GeneratePopulatePropertyFromValue(self,
 651                                          prop,
 652                                          src_var,
 653                                          dst_class_var,
 654                                          failure_value):
 655     """Generates code to populate property |prop| of |dst_class_var| (a
 656     pointer) from a Value*. See |_GeneratePopulateVariableFromValue| for
 657     semantics.
 658     """
 659     return self._GeneratePopulateVariableFromValue(prop.type_,
 660                                                    src_var,
 661                                                    '%s->%s' % (dst_class_var,
 662                                                                prop.unix_name),
 663                                                    failure_value,
 664                                                    is_ptr=prop.optional)
 665
 666   def _GeneratePopulateVariableFromValue(self,
 667                                          type_,
 668                                          src_var,
 669                                          dst_var,
 670                                          failure_value,
 671                                          is_ptr=False):
 672     """Generates code to populate a variable |dst_var| of type |type_| from a
 673     Value* at |src_var|. The Value* is assumed to be non-NULL. In the generated
 674     code, if |dst_var| fails to be populated then Populate will return
 675     |failure_value|.
 676     """
 677     c = Code()
 678
 679     underlying_type = self._type_helper.FollowRef(type_)
 680
 681     if underlying_type.property_type.is_fundamental:
 682       if is_ptr:
 683         (c.Append('%(cpp_type)s temp;')
 684           .Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue(
 685                       self._type_helper.FollowRef(type_), src_var, '&temp'))
 686           .Concat(self._GenerateError(
 687             '"\'%%(key)s\': expected ' + '%s, got " + %s' % (
 688                 type_.name,
 689                 self._util_cc_helper.GetValueTypeString(
 690                     '%%(src_var)s', True)))))
 691         c.Append('%(dst_var)s.reset();')
 692         if not self._generate_error_messages:
 693           c.Append('return %(failure_value)s;')
 694         (c.Eblock('}')
 695           .Append('else')
 696           .Append('  %(dst_var)s.reset(new %(cpp_type)s(temp));')
 697         )
 698       else:
 699         (c.Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue(
 700                       self._type_helper.FollowRef(type_),
 701                       src_var,
 702                       '&%s' % dst_var))
 703           .Concat(self._GenerateError(
 704             '"\'%%(key)s\': expected ' + '%s, got " + %s' % (
 705                 type_.name,
 706                 self._util_cc_helper.GetValueTypeString(
 707                     '%%(src_var)s', True))))
 708           .Append('return %(failure_value)s;')
 709           .Eblock('}')
 710         )
 711     elif underlying_type.property_type == PropertyType.OBJECT:
 712       if is_ptr:
 713         (c.Append('const base::DictionaryValue* dictionary = NULL;')
 714           .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
 715           .Concat(self._GenerateError(
 716             '"\'%%(key)s\': expected dictionary, got " + ' +
 717             self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))))
 718         # If an optional property fails to populate, the population can still
 719         # succeed with a warning. If no error messages are generated, this
 720         # warning is not set and we fail out instead.
 721         if not self._generate_error_messages:
 722           c.Append('return %(failure_value)s;')
 723         (c.Eblock('}')
 724           .Sblock('else {')
 725           .Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
 726           .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
 727             ('*dictionary', 'temp.get()')))
 728           .Append('  return %(failure_value)s;')
 729         )
 730         (c.Append('}')
 731           .Append('else')
 732           .Append('  %(dst_var)s = temp.Pass();')
 733           .Eblock('}')
 734         )
 735       else:
 736         (c.Append('const base::DictionaryValue* dictionary = NULL;')
 737           .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
 738           .Concat(self._GenerateError(
 739             '"\'%%(key)s\': expected dictionary, got " + ' +
 740             self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
 741           .Append('return %(failure_value)s;')
 742           .Eblock('}')
 743           .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
 744             ('*dictionary', '&%(dst_var)s')))
 745           .Append('  return %(failure_value)s;')
 746           .Append('}')
 747         )
 748     elif underlying_type.property_type == PropertyType.FUNCTION:
 749       if is_ptr:
 750         c.Append('%(dst_var)s.reset(new base::DictionaryValue());')
 751     elif underlying_type.property_type == PropertyType.ANY:
 752       c.Append('%(dst_var)s.reset(%(src_var)s->DeepCopy());')
 753     elif underlying_type.property_type == PropertyType.ARRAY:
 754       # util_cc_helper deals with optional and required arrays
 755       (c.Append('const base::ListValue* list = NULL;')
 756         .Sblock('if (!%(src_var)s->GetAsList(&list)) {')
 757           .Concat(self._GenerateError(
 758             '"\'%%(key)s\': expected list, got " + ' +
 759             self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
 760       )
 761       if is_ptr and self._generate_error_messages:
 762         c.Append('%(dst_var)s.reset();')
 763       else:
 764         c.Append('return %(failure_value)s;')
 765       c.Eblock('}')
 766       c.Sblock('else {')
 767       item_type = self._type_helper.FollowRef(underlying_type.item_type)
 768       if item_type.property_type == PropertyType.ENUM:
 769         c.Concat(self._GenerateListValueToEnumArrayConversion(
 770                      item_type,
 771                      'list',
 772                      dst_var,
 773                      failure_value,
 774                      is_ptr=is_ptr))
 775       else:
 776         (c.Sblock('if (!%s) {' % self._util_cc_helper.PopulateArrayFromList(
 777               'list',
 778               dst_var,
 779               is_ptr)))
 780         c.Concat(self._GenerateError(
 781             '"unable to populate array \'%%(parent_key)s\'"'))
 782         if is_ptr and self._generate_error_messages:
 783           c.Append('%(dst_var)s.reset();')
 784         else:
 785           c.Append('return %(failure_value)s;')
 786         c.Eblock('}')
 787       c.Eblock('}')
 788     elif underlying_type.property_type == PropertyType.CHOICES:
 789       if is_ptr:
 790         (c.Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
 791           .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
 792             ('*%(src_var)s', 'temp.get()')))
 793           .Append('  return %(failure_value)s;')
 794           .Append('%(dst_var)s = temp.Pass();')
 795         )
 796       else:
 797         (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
 798             ('*%(src_var)s', '&%(dst_var)s')))
 799           .Append('  return %(failure_value)s;'))
 800     elif underlying_type.property_type == PropertyType.ENUM:
 801       c.Concat(self._GenerateStringToEnumConversion(underlying_type,
 802                                                     src_var,
 803                                                     dst_var,
 804                                                     failure_value))
 805     elif underlying_type.property_type == PropertyType.BINARY:
 806       (c.Append('const base::BinaryValue* binary_value = NULL;')
 807         .Sblock('if (!%(src_var)s->IsType(base::Value::TYPE_BINARY)) {')
 808         .Concat(self._GenerateError(
 809           '"\'%%(key)s\': expected binary, got " + ' +
 810           self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
 811       )
 812       if not self._generate_error_messages:
 813         c.Append('return %(failure_value)s;')
 814       (c.Eblock('}')
 815         .Sblock('else {')
 816         .Append(' binary_value =')
 817         .Append('   static_cast<const base::BinaryValue*>(%(src_var)s);')
 818       )
 819       if is_ptr:
 820         (c.Append('%(dst_var)s.reset(')
 821           .Append('    new std::string(binary_value->GetBuffer(),')
 822           .Append('                    binary_value->GetSize()));')
 823         )
 824       else:
 825         (c.Append('%(dst_var)s.assign(binary_value->GetBuffer(),')
 826           .Append('                   binary_value->GetSize());')
 827         )
 828       c.Eblock('}')
 829     else:
 830       raise NotImplementedError(type_)
 831     if c.IsEmpty():
 832       return c
 833     return Code().Sblock('{').Concat(c.Substitute({
 834       'cpp_type': self._type_helper.GetCppType(type_),
 835       'src_var': src_var,
 836       'dst_var': dst_var,
 837       'failure_value': failure_value,
 838       'key': type_.name,
 839       'parent_key': type_.parent.name,
 840     })).Eblock('}')
 841
 842   def _GenerateListValueToEnumArrayConversion(self,
 843                                               item_type,
 844                                               src_var,
 845                                               dst_var,
 846                                               failure_value,
 847                                               is_ptr=False):
 848     """Returns Code that converts a ListValue of string constants from
 849     |src_var| into an array of enums of |type_| in |dst_var|. On failure,
 850     returns |failure_value|.
 851     """
 852     c = Code()
 853     accessor = '.'
 854     if is_ptr:
 855       accessor = '->'
 856       cpp_type = self._type_helper.GetCppType(item_type, is_in_container=True)
 857       c.Append('%s.reset(new std::vector<%s>);' %
 858                    (dst_var, cpp_util.PadForGenerics(cpp_type)))
 859     (c.Sblock('for (base::ListValue::const_iterator it = %s->begin(); '
 860                    'it != %s->end(); ++it) {' % (src_var, src_var))
 861       .Append('%s tmp;' % self._type_helper.GetCppType(item_type))
 862       .Concat(self._GenerateStringToEnumConversion(item_type,
 863                                                    '(*it)',
 864                                                    'tmp',
 865                                                    failure_value))
 866       .Append('%s%spush_back(tmp);' % (dst_var, accessor))
 867       .Eblock('}')
 868     )
 869     return c
 870
 871   def _GenerateStringToEnumConversion(self,
 872                                       type_,
 873                                       src_var,
 874                                       dst_var,
 875                                       failure_value):
 876     """Returns Code that converts a string type in |src_var| to an enum with
 877     type |type_| in |dst_var|. In the generated code, if |src_var| is not
 878     a valid enum name then the function will return |failure_value|.
 879     """
 880     if type_.property_type != PropertyType.ENUM:
 881       raise TypeError(type_)
 882     c = Code()
 883     enum_as_string = '%s_as_string' % type_.unix_name
 884     cpp_type_namespace = ''
 885     if type_.namespace != self._namespace:
 886       cpp_type_namespace = '%s::' % type_.namespace.unix_name
 887     cpp_type_name = self._type_helper.GetCppType(type_)
 888     (c.Append('std::string %s;' % enum_as_string)
 889       .Sblock('if (!%s->GetAsString(&%s)) {' % (src_var, enum_as_string))
 890       .Concat(self._GenerateError(
 891         '"\'%%(key)s\': expected string, got " + ' +
 892         self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
 893       .Append('return %s;' % failure_value)
 894       .Eblock('}')
 895       .Append('%s = %sParse%s(%s);' % (dst_var,
 896                                        cpp_type_namespace,
 897                                        cpp_util.Classname(type_.name),
 898                                        enum_as_string))
 899       .Sblock('if (%s == %s%s) {' % (dst_var,
 900                                      cpp_type_namespace,
 901                                      self._type_helper.GetEnumNoneValue(type_)))
 902       .Concat(self._GenerateError(
 903         '\"\'%%(key)s\': expected \\"' +
 904         '\\" or \\"'.join(
 905             enum_value.name
 906             for enum_value in self._type_helper.FollowRef(type_).enum_values) +
 907         '\\", got \\"" + %s + "\\""' % enum_as_string))
 908       .Append('return %s;' % failure_value)
 909       .Eblock('}')
 910       .Substitute({'src_var': src_var, 'key': type_.name})
 911     )
 912     return c
 913
 914   def _GeneratePropertyFunctions(self, namespace, params):
 915     """Generates the member functions for a list of parameters.
 916     """
 917     return self._GenerateTypes(namespace, (param.type_ for param in params))
 918
 919   def _GenerateTypes(self, namespace, types):
 920     """Generates the member functions for a list of types.
 921     """
 922     c = Code()
 923     for type_ in types:
 924       c.Cblock(self._GenerateType(namespace, type_))
 925     return c
 926
 927   def _GenerateEnumToString(self, cpp_namespace, type_):
 928     """Generates ToString() which gets the string representation of an enum.
 929     """
 930     c = Code()
 931     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
 932
 933     if cpp_namespace is not None:
 934       c.Append('// static')
 935     maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace
 936
 937     c.Sblock('std::string %sToString(%s enum_param) {' %
 938                  (maybe_namespace, classname))
 939     c.Sblock('switch (enum_param) {')
 940     for enum_value in self._type_helper.FollowRef(type_).enum_values:
 941       name = enum_value.name
 942       if 'camel_case_enum_to_string' in self._namespace.compiler_options:
 943         name = enum_value.CamelName()
 944       (c.Append('case %s: ' % self._type_helper.GetEnumValue(type_, enum_value))
 945         .Append('  return "%s";' % name))
 946     (c.Append('case %s:' % self._type_helper.GetEnumNoneValue(type_))
 947       .Append('  return "";')
 948       .Eblock('}')
 949       .Append('NOTREACHED();')
 950       .Append('return "";')
 951       .Eblock('}')
 952     )
 953     return c
 954
 955   def _GenerateEnumFromString(self, cpp_namespace, type_):
 956     """Generates FromClassNameString() which gets an enum from its string
 957     representation.
 958     """
 959     c = Code()
 960     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
 961
 962     if cpp_namespace is not None:
 963       c.Append('// static')
 964     maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace
 965
 966     c.Sblock('%s%s %sParse%s(const std::string& enum_string) {' %
 967                  (maybe_namespace, classname, maybe_namespace, classname))
 968     for i, enum_value in enumerate(
 969           self._type_helper.FollowRef(type_).enum_values):
 970       # This is broken up into all ifs with no else ifs because we get
 971       # "fatal error C1061: compiler limit : blocks nested too deeply"
 972       # on Windows.
 973       (c.Append('if (enum_string == "%s")' % enum_value.name)
 974         .Append('  return %s;' %
 975             self._type_helper.GetEnumValue(type_, enum_value)))
 976     (c.Append('return %s;' % self._type_helper.GetEnumNoneValue(type_))
 977       .Eblock('}')
 978     )
 979     return c
 980
 981   def _GenerateCreateCallbackArguments(self,
 982                                        cpp_namespace,
 983                                        function_scope,
 984                                        callback):
 985     """Generate all functions to create Value parameters for a callback.
 986
 987     E.g for function "Bar", generate Bar::Results::Create
 988     E.g for event "Baz", generate Baz::Create
 989
 990     function_scope: the function scope path, e.g. Foo::Bar for the function
 991                     Foo::Bar::Baz(). May be None if there is no function scope.
 992     callback: the Function object we are creating callback arguments for.
 993     """
 994     c = Code()
 995     params = callback.params
 996     c.Concat(self._GeneratePropertyFunctions(function_scope, params))
 997
 998     (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s'
 999                   'Create(%(declaration_list)s) {')
1000       .Append('scoped_ptr<base::ListValue> create_results('
1001               'new base::ListValue());')
1002     )
1003     declaration_list = []
1004     for param in params:
1005       declaration_list.append(cpp_util.GetParameterDeclaration(
1006           param, self._type_helper.GetCppType(param.type_)))
1007       c.Cblock(self._CreateValueFromType('create_results->Append(%s);',
1008                                          param.name,
1009                                          param.type_,
1010                                          param.unix_name))
1011     c.Append('return create_results.Pass();')
1012     c.Eblock('}')
1013     c.Substitute({
1014         'function_scope': ('%s::' % function_scope) if function_scope else '',
1015         'declaration_list': ', '.join(declaration_list),
1016         'param_names': ', '.join(param.unix_name for param in params)
1017     })
1018     return c
1019
1020   def _GenerateEventNameConstant(self, function_scope, event):
1021     """Generates a constant string array for the event name.
1022     """
1023     c = Code()
1024     c.Append('const char kEventName[] = "%s.%s";' % (
1025                  self._namespace.name, event.name))
1026     return c
1027
1028   def _InitializePropertyToDefault(self, prop, dst):
1029     """Initialize a model.Property to its default value inside an object.
1030
1031     E.g for optional enum "state", generate dst->state = STATE_NONE;
1032
1033     dst: Type*
1034     """
1035     c = Code()
1036     underlying_type = self._type_helper.FollowRef(prop.type_)
1037     if (underlying_type.property_type == PropertyType.ENUM and
1038         prop.optional):
1039       c.Append('%s->%s = %s;' % (
1040         dst,
1041         prop.unix_name,
1042         self._type_helper.GetEnumNoneValue(prop.type_)))
1043     return c
1044
1045   def _GenerateError(self, body):
1046     """Generates an error message pertaining to population failure.
1047
1048     E.g 'expected bool, got int'
1049     """
1050     c = Code()
1051     if not self._generate_error_messages:
1052       return c
1053     (c.Append('if (error->length())')
1054       .Append('  error->append(UTF8ToUTF16("; "));')
1055       .Append('error->append(UTF8ToUTF16(%s));' % body))
1056     return c
1057
1058   def _GenerateParams(self, params):
1059     """Builds the parameter list for a function, given an array of parameters.
1060     """
1061     if self._generate_error_messages:
1062       params = list(params) + ['base::string16* error']
1063     return ', '.join(str(p) for p in params)
1064
1065   def _GenerateArgs(self, args):
1066     """Builds the argument list for a function, given an array of arguments.
1067     """
1068     if self._generate_error_messages:
1069       args = list(args) + ['error']
1070     return ', '.join(str(a) for a in args)