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