# Copyright 2012 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from code_util import Code
from model import PropertyType, Property, Type
import cpp_util
import schema_util
import util_cc_helper
from cpp_namespace_environment import CppNamespaceEnvironment


class CCGenerator(object):

  def __init__(self, type_generator):
    self._type_generator = type_generator

  def Generate(self, namespace):
    return _Generator(namespace, self._type_generator).Generate()


class _Generator(object):
  """A .cc generator for a namespace.
  """

  def __init__(self, namespace, cpp_type_generator):
    assert type(namespace.environment) is CppNamespaceEnvironment
    self._namespace = namespace
    self._type_helper = cpp_type_generator
    self._util_cc_helper = (util_cc_helper.UtilCCHelper(self._type_helper))
    self._generate_error_messages = namespace.compiler_options.get(
        'generate_error_messages', False)

  def Generate(self):
    """Generates a Code object with the .cc for a single namespace.
    """
    cpp_namespace = cpp_util.GetCppNamespace(
        self._namespace.environment.namespace_pattern,
        self._namespace.unix_name)

    c = Code()
    (c.Append(cpp_util.CHROMIUM_LICENSE) \
      .Append() \
      .Append(cpp_util.GENERATED_FILE_MESSAGE %
              cpp_util.ToPosixPath(self._namespace.source_file)) \
      .Append() \
      .Append('#include "%s/%s.h"' %
              (cpp_util.ToPosixPath(self._namespace.source_file_dir),
               self._namespace.short_filename)) \
      .Append() \
      .Append('#include <memory>') \
      .Append('#include <optional>') \
      .Append('#include <ostream>') \
      .Append('#include <string>') \
      .Append('#include <string_view>') \
      .Append('#include <utility>') \
      .Append('#include <vector>') \
      .Append() \
      .Append('#include "base/check.h"') \
      .Append('#include "base/check_op.h"') \
      .Append('#include "base/notreached.h"') \
      .Append('#include "base/strings/string_number_conversions.h"') \
      .Append('#include "base/strings/utf_string_conversions.h"') \
      .Append('#include "base/values.h"') \
      .Append(self._util_cc_helper.GetIncludePath()) \
      .Cblock(self._GenerateManifestKeysIncludes()) \
      .Cblock(self._type_helper.GenerateIncludes(include_soft=True,
          generate_error_messages=self._generate_error_messages)) \
      .Append() \
      .Append('using base::UTF8ToUTF16;') \
      .Append() \
      .Concat(cpp_util.OpenNamespace(cpp_namespace))
    )
    if self._namespace.properties:
      (c.Append('//') \
        .Append('// Properties') \
        .Append('//') \
        .Append()
      )
      for prop in self._namespace.properties.values():
        property_code = self._type_helper.GeneratePropertyValues(
            prop, 'const %(type)s %(name)s = %(value)s;', nodoc=True)
        if property_code:
          c.Cblock(property_code)
    if self._namespace.types:
      (c.Append('//') \
        .Append('// Types') \
        .Append('//') \
        .Append() \
        .Cblock(self._GenerateTypes(None, self._namespace.types.values()))
      )
    if self._namespace.manifest_keys:
      (c.Append('//') \
        .Append('// Manifest Keys') \
        .Append('//') \
        .Append() \
        .Cblock(self._GenerateManifestKeys())
      )
    if self._namespace.functions:
      (c.Append('//') \
        .Append('// Functions') \
        .Append('//') \
        .Append()
      )
    for function in self._namespace.functions.values():
      c.Cblock(self._GenerateFunction(function))
    if self._namespace.events:
      (c.Append('//') \
        .Append('// Events') \
        .Append('//') \
        .Append()
      )
      for event in self._namespace.events.values():
        c.Cblock(self._GenerateEvent(event))
    c.Cblock(cpp_util.CloseNamespace(cpp_namespace))
    c.Append()
    return c

  def _GenerateType(self, cpp_namespace, type_):
    """Generates the function definitions for a type.
    """
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
    c = Code()

    if type_.functions:
      # Wrap functions within types in the type's namespace.
      (c.Append('namespace %s {' % classname) \
        .Append())
      for function in type_.functions.values():
        c.Cblock(self._GenerateFunction(function))
      c.Append('}  // namespace %s' % classname)
    elif type_.property_type == PropertyType.ARRAY:
      c.Cblock(self._GenerateType(cpp_namespace, type_.item_type))
    elif type_.property_type in (PropertyType.CHOICES, PropertyType.OBJECT):
      if cpp_namespace is None:
        classname_in_namespace = classname
      else:
        classname_in_namespace = '%s::%s' % (cpp_namespace, classname)

      if type_.property_type == PropertyType.OBJECT:
        c.Cblock(
            self._GeneratePropertyFunctions(classname_in_namespace,
                                            type_.properties.values()))
      else:
        c.Cblock(self._GenerateTypes(classname_in_namespace, type_.choices))

      (c.Append('%s::%s()' % (classname_in_namespace, classname)) \
        .Cblock(self._GenerateInitializersAndBody(type_)) \
        .Append('%s::~%s() = default;' % (classname_in_namespace, classname))
      )
      # Note: we use 'rhs' because some API objects have a member 'other'.
      (c.Append('%s::%s(%s&& rhs) noexcept = default;' %
                    (classname_in_namespace, classname, classname)) \
        .Append('%s& %s::operator=(%s&& rhs) noexcept = default;' %
                    (classname_in_namespace, classname_in_namespace,
                     classname))
      )

      if type_.origin.from_manifest_keys:
        c.Cblock(
            self._GenerateManifestKeyConstants(classname_in_namespace,
                                               type_.properties.values()))
        # Manifest key parsing for CHOICES types relies on the Populate()
        # method. Thus, if it wouldn't be generated below, ensure it's
        # created here.
        # TODO(devlin): This gets precarious. Instead of having complex if-
        # branches determining which values to construct here, we should pull
        # this out to a helper that just returns a set of method categories to
        # generate.
        if (type_.property_type is PropertyType.CHOICES
            and not type_.origin.from_json):
          c.Cblock(
              self._GenerateTypePopulateFromValue(classname_in_namespace,
                                                  type_))

      if type_.origin.from_json:
        c.Cblock(self._GenerateClone(classname_in_namespace, type_))
        if type_.property_type is not PropertyType.CHOICES:
          c.Cblock(self._GenerateTypePopulate(classname_in_namespace, type_))
        c.Cblock(
            self._GenerateTypePopulateFromValue(classname_in_namespace, type_))

        if type_.property_type is not PropertyType.CHOICES:
          c.Cblock(
              self._GenerateTypeFromValue(classname_in_namespace,
                                          type_,
                                          is_dict=True))

        c.Cblock(
            self._GenerateTypeFromValue(classname_in_namespace,
                                        type_,
                                        is_dict=False))
      if type_.origin.from_client:
        c.Cblock(self._GenerateTypeToValue(classname_in_namespace, type_))

      if type_.origin.from_manifest_keys:
        c.Cblock(
            self._GenerateParseFromDictionary(classname, classname_in_namespace,
                                              type_))
    elif type_.property_type == PropertyType.ENUM:
      (c.Cblock(self._GenerateEnumToString(cpp_namespace, type_)) \
        .Cblock(self._GenerateEnumFromString(cpp_namespace, type_)) \
        .Cblock(self._GenerateEnumParseErrorMessage(cpp_namespace, type_))
      )

    return c

  def _GenerateInitializersAndBody(self, type_):
    items = []
    for prop in type_.properties.values():
      t = prop.type_

      real_t = self._type_helper.FollowRef(t)
      if real_t.property_type == PropertyType.ENUM:
        items.append('{var_name}()'.format(var_name=prop.unix_name))
      elif prop.optional:
        continue
      elif t.property_type == PropertyType.INTEGER:
        items.append('%s(0)' % prop.unix_name)
      elif t.property_type == PropertyType.DOUBLE:
        items.append('%s(0.0)' % prop.unix_name)
      elif t.property_type == PropertyType.BOOLEAN:
        items.append('%s(false)' % prop.unix_name)
      elif (t.property_type == PropertyType.ANY
            or t.property_type == PropertyType.ARRAY
            or t.property_type == PropertyType.BINARY
            or t.property_type == PropertyType.CHOICES
            or t.property_type == PropertyType.OBJECT
            or t.property_type == PropertyType.FUNCTION
            or t.property_type == PropertyType.REF
            or t.property_type == PropertyType.STRING):
        # TODO(miket): It would be nice to initialize CHOICES, but we
        # don't presently have the semantics to indicate which one of a set
        # should be the default.
        continue
      else:
        raise TypeError(t)

    if items:
      s = ': %s' % (',\n'.join(items))
    else:
      s = ''
    s = s + ' {}'
    return Code().Append(s)

  def _GenerateCloneItem(self, type_, field_name, is_optional):
    """Generates the cloning statement for an individual data member.
    """

    underlying_type = self._type_helper.FollowRef(type_)
    c = Code()

    if (type_.property_type == PropertyType.ARRAY
        and self._type_helper.FollowRef(type_.item_type).property_type
        in (PropertyType.ANY, PropertyType.OBJECT)):
      if is_optional:
        (c.Sblock('if (%(name)s) {') \
            .Append('out.%(name)s.emplace();') \
            .Append('out.%(name)s->reserve(%(name)s->size());') \
            .Sblock('for (const auto& element : *%(name)s) {') \
              .Append(self._util_cc_helper.AppendToContainer(
                '*out.%(name)s', 'element.Clone()')) \
            .Eblock('}') \
          .Eblock('}'))
      else:
        (c.Append('out.%(name)s.reserve(%(name)s.size());') \
          .Sblock('for (const auto& element : %(name)s) {') \
            .Append(self._util_cc_helper.AppendToContainer(
              'out.%(name)s', 'element.Clone()')) \
          .Eblock('}'))
    elif (underlying_type.property_type == PropertyType.OBJECT
          or underlying_type.property_type == PropertyType.ANY
          or underlying_type.property_type == PropertyType.CHOICES
          or (underlying_type.property_type == PropertyType.FUNCTION
              and not type_.is_serializable_function)):
      if is_optional:
        (c.Sblock('if (%(name)s) {') \
          .Append('out.%(name)s = %(name)s->Clone();') \
          .Eblock('}'))
      else:
        c.Append('out.%(name)s = %(name)s.Clone();')
    else:
      c.Append('out.%(name)s = %(name)s;')

    c.Substitute({'name': field_name})
    return c

  def _GenerateClone(self, cpp_namespace, type_):
    """Generates the function for cloning a type.
    """
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
    c = Code()
    c.Sblock('%(namespace)s %(namespace)s::Clone() const {')
    c.Append('%(classname)s out;')

    if type_.property_type is PropertyType.CHOICES:
      for choice in type_.choices:
        c.Concat(
            self._GenerateCloneItem(choice,
                                    'as_%s' % choice.unix_name,
                                    is_optional=True))
    else:
      if type_.additional_properties is not None:
        if type_.additional_properties.property_type == PropertyType.ANY:
          c.Append('out.additional_properties = additional_properties.Clone();')
      else:
        for prop in type_.properties.values():
          c.Concat(
              self._GenerateCloneItem(prop.type_,
                                      prop.type_.unix_name,
                                      is_optional=prop.optional))

    (c.Append('return out;') \
      .Eblock('}') \
      .Substitute({'namespace': cpp_namespace, 'classname': classname}))
    return c

  def _GenerateTypePopulate(self, cpp_namespace, type_):
    """Generates the function for populating a type given a pointer to it.

    E.g for type "Foo", generates:
        bool Foo::Populate(const base::Value::Dict& dict, Foo& out)
    """
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
    c = Code()
    (c.Append('// static') \
      .Append('bool %(namespace)s::Populate(') \
      .Sblock('    %s) {' % self._GenerateParams(
          ('const base::Value::Dict& dict', '%(name)s& out'))))

    # TODO(crbug.com/40729306): The generated code here will ignore
    # unrecognized keys, but the parsing code for types passed to APIs in the
    # renderer will hard-error on them. We should probably be consistent with
    # the renderer here (at least for types also parsed in the renderer).
    for prop in type_.properties.values():
      c.Concat(self._InitializePropertyToDefault(prop, 'out'))
    for prop in type_.properties.values():
      c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out'))
    if type_.additional_properties is not None:
      if type_.additional_properties.property_type == PropertyType.ANY:
        c.Append('out.additional_properties.Merge(dict.Clone());')
      else:
        cpp_type = self._type_helper.GetCppType(type_.additional_properties)
        (c.Sblock('for (const auto item : dict) {') \
            .Append('%s tmp;' % cpp_type) \
            .Concat(self._GeneratePopulateVariableFromValue(
                type_.additional_properties,
                'item.second',
                'tmp',
                'false')) \
            .Append('out.additional_properties[item.first] = tmp;') \
          .Eblock('}')
        )
    c.Append('return true;')
    (c.Eblock('}') \
      .Substitute({'namespace': cpp_namespace, 'name': classname}))
    return c

  def _GenerateTypePopulateFromValue(self, cpp_namespace, type_):
    """Generates the function for populating a type receiving a base::Value
    instance.

    E.g for choice type "Foo", generates:
        bool Foo::Populate(const base::Value& value, Foo& out)
    """
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
    c = Code()
    (c.Append('// static') \
      .Append('bool %(namespace)s::Populate(') \
      .Sblock('    %s) {' % self._GenerateParams(
          ('const base::Value& value', '%(name)s& out'))))

    if type_.property_type is PropertyType.CHOICES:
      for choice in type_.choices:
        (c.Sblock('if (%s) {' % self._GenerateValueIsTypeExpression('value',
                                                                    choice)) \
            .Concat(self._GeneratePopulateVariableFromValue(
                choice,
                'value',
                'out.as_%s' % choice.unix_name,
                'false',
                is_ptr=True)) \
            .Append('return true;') \
          .Eblock('}')
        )
      (c.Concat(self._AppendError16(
          'u"expected %s, got " + %s' %
              (" or ".join(choice.name for choice in type_.choices),
              self._util_cc_helper.GetValueTypeString('value')))) \
        .Append('return false;'))
    elif type_.property_type == PropertyType.OBJECT:
      (c.Sblock('if (!value.is_dict()) {') \
        .Concat(self._AppendError16(
          'u"expected dictionary, got " + ' +
          self._util_cc_helper.GetValueTypeString('value'))) \
        .Append('return false;') \
        .Eblock('}'))
      (c.Append('return Populate(%s);' % self._GenerateArgs(
          ('value.GetDict()', 'out'))))

    (c.Eblock('}') \
      .Substitute({'namespace': cpp_namespace, 'name': classname}))
    return c

  def _GenerateValueIsTypeExpression(self, var, type_):
    real_type = self._type_helper.FollowRef(type_)
    if real_type.property_type is PropertyType.CHOICES:
      return '(%s)' % ' || '.join(
          self._GenerateValueIsTypeExpression(var, choice)
          for choice in real_type.choices)
    return '%s.type() == %s' % (var, cpp_util.GetValueType(real_type))

  def _GenerateTypePopulateProperty(self, prop, src, dst):
    """Generate the code to populate a single property in a type.

    src: base::Value::Dict*
    dst: Type*
    """
    c = Code()
    value_var = prop.unix_name + '_value'
    c.Append('const base::Value* %(value_var)s = %(src)s.Find("%(key)s");')
    if prop.optional:
      (c.Sblock(
          'if (%(value_var)s) {') \
        .Concat(self._GeneratePopulatePropertyFromValue(
            prop, '(*%s)' % value_var, dst, 'false')))
      underlying_type = self._type_helper.FollowRef(prop.type_)
      if underlying_type.property_type == PropertyType.ENUM:
        (c.Append('} else {') \
          .Append('%%(dst)s.%%(name)s = %s;' %
            self._type_helper.GetEnumDefaultValue(underlying_type,
                                                  self._namespace)))
      c.Eblock('}')
    else:
      (c.Sblock(
          'if (!%(value_var)s) {') \
        .Concat(self._AppendError16('u"\'%%(key)s\' is required"')) \
        .Append('return false;') \
        .Eblock('}') \
        .Concat(self._GeneratePopulatePropertyFromValue(
            prop, '(*%s)' % value_var, dst, 'false'))
      )
    c.Append()
    c.Substitute({
        'value_var': value_var,
        'key': prop.name,
        'src': src,
        'dst': dst,
        'name': prop.unix_name
    })
    return c

  def _GenerateTypeFromValue(self, cpp_namespace, type_, is_dict):
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))

    return_type = self._type_helper.GetOptionalReturnType(
        cpp_namespace, support_errors=self._generate_error_messages)

    param_type = ('base::Value::Dict' if is_dict else 'base::Value')

    c = Code()
    (c.Append(f'// static') \
      .Append('{return_type} '
              '{classname}::FromValue(const {param_type}& value) {{'.format(
                return_type=return_type,
                classname=cpp_namespace,
                param_type=param_type))
    )
    c.Sblock()
    # TODO(crbug.com/40235429): Once the deprecated version of this method is
    # removed, we should consider making Populate return an optional, rather
    # than using an out param.
    if self._generate_error_messages:
      c.Append('std::u16string error;')

    c.Append(f'{classname} out;')
    c.Append('bool result = Populate(%s);' % self._GenerateArgs(
        ('value', 'out')))

    c.Sblock('if (!result) {')
    if self._generate_error_messages:
      c.Append('DCHECK(!error.empty());')
      c.Append('return base::unexpected(std::move(error));')
    else:
      c.Append('return std::nullopt;')
    c.Eblock('}')

    c.Append('return out;')
    c.Eblock('}')
    return c

  def _GenerateTypeToValue(self, cpp_namespace, type_):
    """Generates a function that serializes the type into a base::Value.
    E.g. for type "Foo" generates Foo::ToValue()
    """
    if type_.property_type == PropertyType.OBJECT:
      return self._GenerateObjectTypeToValue(cpp_namespace, type_)
    elif type_.property_type == PropertyType.CHOICES:
      return self._GenerateChoiceTypeToValue(cpp_namespace, type_)
    else:
      raise ValueError("Unsupported property type %s" % type_.type_)

  def _GenerateManifestKeysIncludes(self):
    # type: () -> (Code)
    """Returns the includes needed for manifest key parsing.
    """
    c = Code()
    if not self._namespace.manifest_keys:
      return c

    c.Append('#include "tools/json_schema_compiler/manifest_parse_util.h"')
    return c

  def _GenerateManifestKeyConstants(self, classname_in_namespace, properties):
    # type: (str, List[Property]) -> Code
    """ Generates the definition for manifest key constants declared in the
    header.
    """
    c = Code()
    for prop in properties:
      c.Comment('static')
      c.Append('constexpr char %s::%s[];' %
               (classname_in_namespace,
                cpp_util.UnixNameToConstantName(prop.unix_name)))

    return c

  def _GenerateManifestKeys(self):
    # type: () -> Code
    """Generates the types and parsing code for manifest keys.
    """
    assert self._namespace.manifest_keys
    assert self._namespace.manifest_keys.property_type == PropertyType.OBJECT
    return self._GenerateType(None, self._namespace.manifest_keys)

  def _GenerateParseFromDictionary(self, classname, classname_in_namespace,
                                   type_):
    # type: (str, str, Type) -> Code
    """Generates a function that deserializes the type from the passed
    dictionary. E.g. for type "Foo", generates Foo::ParseFromDictionary().
    """
    if type_.IsRootManifestKeyType():
      # Root manifest types must always be objects.
      assert type_.property_type == PropertyType.OBJECT, \
        ('Manifest type %s must be an object, but it is: %s' %
        (type_.name, type_.property_type))
      return self._GenerateParseFromDictionaryForRootManifestType(
          classname, classname_in_namespace, type_.properties.values())

    return self._GenerateParseFromDictionaryForChildManifestType(
        type_, classname, classname_in_namespace, type_.properties.values())

  def _GenerateParseFromDictionaryForRootManifestType(self, classname,
                                                      classname_in_namespace,
                                                      properties):
    # type: (str, str, List[Property]) -> Code
    """Generates definition for ManifestKeys::ParseFromDictionary.
    """
    params = [
        'const base::Value::Dict& root_dict',
        '%(classname)s& out',
    ]

    c = Code()
    c.Append('//static')
    c.Append('bool %(classname_in_namespace)s::ParseFromDictionary(')

    # Make |generate_error_messages| True since we always generate error
    # messages for manifest parsing.
    c.Sblock('%s) {' %
             self._GenerateParams(params, generate_error_messages=True))

    c.Append()

    c.Append('std::vector<std::string_view> error_path_reversed;')
    c.Append('const base::Value::Dict& dict = root_dict;')

    for prop in properties:
      c.Concat(self._InitializePropertyToDefault(prop, 'out'))

    for prop in properties:
      c.Cblock(
          self._ParsePropertyFromDictionary(prop, is_root_manifest_type=True))

    c.Append('return true;')
    c.Eblock('}')
    c.Substitute({
        'classname_in_namespace': classname_in_namespace,
        'classname': classname
    })
    return c

  def _GenerateParseFromDictionaryForChildManifestType(self, type_, classname,
                                                       classname_in_namespace,
                                                       properties):
    # type: (str, str, List[Property]) -> Code
    """Generates T::ParseFromDictionary for a child manifest type.
    """
    params = [
        'const base::Value::Dict& root_dict', 'std::string_view key',
        '%(classname)s& out', 'std::u16string& error',
        'std::vector<std::string_view>& error_path_reversed'
    ]

    c = Code()
    c.Append('//static')
    c.Append('bool %(classname_in_namespace)s::ParseFromDictionary(')

    # Make |generate_error_messages| False since |error| is already included
    # within |params|.
    c.Sblock('%s) {' %
             self._GenerateParams(params, generate_error_messages=False))

    c.Append()

    # For CHOICES, we leverage the specialized helper in manifest_parse_util.
    if type_.property_type is PropertyType.CHOICES:
      c.Append('return ::json_schema_compiler::manifest_parse_util::\n'
               '    ParseChoicesFromDictionary(root_dict, key, out, error,\n'
               '                               error_path_reversed);')
      c.Eblock('}')
      return c.Substitute({
          'classname_in_namespace': classname_in_namespace,
          'classname': classname
      })

    # Otherwise, this must be an object, and we parse each property
    # individually.
    assert type_.property_type == PropertyType.OBJECT, \
      ('Manifest type %s must be an object, but it is: %s' %
      (type_.name, type_.property_type))

    c.Append('const base::Value* value = '
             '::json_schema_compiler::manifest_parse_util::FindKeyOfType('
             'root_dict, key, base::Value::Type::DICT, error, '
             'error_path_reversed);')
    c.Sblock('if (!value)')
    c.Append('return false;')
    if len(properties) > 0:
      c.Eblock('const base::Value::Dict& dict = value->GetDict();')
    else:
      c.Eblock('')

    for prop in properties:
      c.Concat(self._InitializePropertyToDefault(prop, 'out'))

    for prop in properties:
      c.Cblock(
          self._ParsePropertyFromDictionary(prop, is_root_manifest_type=False))

    c.Append('return true;')
    c.Eblock('}')
    c.Substitute({
        'classname_in_namespace': classname_in_namespace,
        'classname': classname
    })
    return c

  def _ParsePropertyFromDictionary(self, property, is_root_manifest_type):
    # type: (Property, bool) -> Code
    """Generates the code to parse a single property from a dictionary.
    """
    supported_property_types = {
        PropertyType.ARRAY,
        PropertyType.BOOLEAN,
        PropertyType.DOUBLE,
        PropertyType.INT64,
        PropertyType.INTEGER,
        PropertyType.CHOICES,
        PropertyType.OBJECT,
        PropertyType.STRING,
        PropertyType.ENUM,
    }

    c = Code()
    underlying_type = self._type_helper.FollowRef(property.type_)
    underlying_property_type = underlying_type.property_type
    underlying_item_type = (self._type_helper.FollowRef(
        underlying_type.item_type) if underlying_property_type
                            is PropertyType.ARRAY else None)

    assert (underlying_property_type in supported_property_types), (
        'Property type not implemented for %s, type: %s, namespace: %s' %
        (underlying_property_type, underlying_type.name,
         underlying_type.namespace.name))

    property_constant = cpp_util.UnixNameToConstantName(property.unix_name)
    out_expression = 'out.%s' % property.unix_name

    def get_enum_params(enum_type, include_optional_param):
      # type: (Type, bool) -> List[str]
      enum_name = cpp_util.Classname(schema_util.StripNamespace(enum_type.name))
      cpp_type_namespace = ('' if enum_type.namespace == self._namespace else
                            '%s::' % enum_type.namespace.unix_name)

      params = [
          'dict',
          '%s' % property_constant,
          '&%sParse%s' % (cpp_type_namespace, enum_name)
      ]
      if include_optional_param:
        params.append('true' if property.optional else 'false')
      params += [
          '%s' %
          self._type_helper.GetEnumDefaultValue(enum_type, self._namespace),
          '%s' % out_expression, 'error', 'error_path_reversed'
      ]
      return params

    if underlying_property_type == PropertyType.ENUM:
      params = get_enum_params(underlying_type, include_optional_param=True)
      func_name = 'ParseEnumFromDictionary'
    elif underlying_item_type and \
      underlying_item_type.property_type == PropertyType.ENUM:
      # Array of enums.
      params = get_enum_params(underlying_item_type,
                               include_optional_param=False)
      func_name = 'ParseEnumArrayFromDictionary'
    else:
      params = [
          'dict',
          '%s' % property_constant,
          '%s' % out_expression, 'error', 'error_path_reversed'
      ]
      func_name = 'ParseFromDictionary'

    c.Sblock('if (!::json_schema_compiler::manifest_parse_util::%s(%s)) {' %
             (func_name,
              self._GenerateParams(params, generate_error_messages=False)))
    if is_root_manifest_type:
      c.Append('::json_schema_compiler::manifest_parse_util::'
               'PopulateFinalError(error, error_path_reversed);')
    else:
      c.Append('error_path_reversed.push_back(key);')
    c.Append('return false;')
    c.Eblock('}')

    return c

  def _GenerateObjectTypeToValue(self, cpp_namespace, type_):
    """Generates a function that serializes an object-representing type
    into a base::Value::Dict.
    """
    c = Code()
    (c.Sblock('base::Value::Dict %s::ToValue() const {' % cpp_namespace) \
        .Append('base::Value::Dict to_value_result;') \
        .Append()
    )

    for prop in type_.properties.values():
      prop_var = 'this->%s' % prop.unix_name
      if prop.optional:
        underlying_type = self._type_helper.FollowRef(prop.type_)
        if underlying_type.property_type == PropertyType.ENUM:
          # Optional enum values are generated with default initialisation (e.g.
          # kNone), potentially from another namespace.
          c.Sblock('if (%s != %s) {' % (prop_var,
                                        self._type_helper.GetEnumDefaultValue(
                                            underlying_type, self._namespace)))
        else:
          c.Sblock('if (%s) {' % prop_var)

      c.Cblock(
          self._CreateValueFromType('to_value_result.Set("%s", %%s);' %
                                    prop.name,
                                    prop.name,
                                    prop.type_,
                                    prop_var,
                                    is_ptr=prop.optional))

      if prop.optional:
        c.Eblock('}')

    if type_.additional_properties is not None:
      if type_.additional_properties.property_type == PropertyType.ANY:
        c.Append('to_value_result.Merge(additional_properties.Clone());')
      else:
        (c.Sblock('for (const auto& it : additional_properties) {') \
          .Cblock(self._CreateValueFromType(
              'to_value_result.Set(it.first, %s);',
              type_.additional_properties.name,
              type_.additional_properties,
              'it.second')) \
          .Eblock('}')
        )

    return (c.Append() \
             .Append('return to_value_result;') \
           .Eblock('}'))

  def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
    """Generates a function that serializes a choice-representing type
    into a base::Value.
    """
    c = Code()
    c.Sblock('base::Value %s::ToValue() const {' % cpp_namespace)
    c.Append('base::Value result;')
    for choice in type_.choices:
      choice_var = 'as_%s' % choice.unix_name

      # Enum class values cannot be checked as a boolean, so they require
      # specific handling when checking if they are engaged, by comparing it
      # against kNone.
      if (self._type_helper.FollowRef(choice).property_type == PropertyType.ENUM
          ):
        comparison_expr = '{enum_var} != {default_value}'.format(
            enum_var=choice_var,
            default_value=self._type_helper.GetEnumDefaultValue(
                choice, self._namespace))
      else:
        comparison_expr = choice_var

      (c.Sblock('if (%s) {' % comparison_expr) \
       .Append('DCHECK(result.is_none()) << "Cannot set multiple choices for '
               '%s";' %
               type_.unix_name).Cblock(self._CreateValueFromType(
                   'result = base::Value(%s);', choice.name, choice, choice_var,
                   True)) \
       .Eblock('}'))
    (c.Append('DCHECK(!result.is_none()) << "Must set at least one choice for '
              '%s";' % type_.unix_name).Append('return result;').Eblock('}'))
    return c

  def _GenerateFunction(self, function):
    """Generates the definitions for function structs.
    """
    c = Code()

    # TODO(kalman): use function.unix_name not Classname.
    function_namespace = cpp_util.Classname(function.name)
    # Windows has a #define for SendMessage, so to avoid any issues, we need
    # to not use the name.
    if function_namespace == 'SendMessage':
      function_namespace = 'PassMessage'
    (c.Append('namespace %s {' % function_namespace) \
      .Append()
    )

    # Params::Populate function
    if function.params:
      c.Concat(self._GeneratePropertyFunctions('Params', function.params))
      (c.Append('Params::Params() = default;') \
        .Append('Params::~Params() = default;') \
        .Append('Params::Params(Params&& rhs) noexcept = default;') \
        .Append('Params& Params::operator=(Params&& rhs) noexcept = default;') \
        .Append() \
        .Cblock(self._GenerateFunctionParamsCreate(function))
      )
      if self._generate_error_messages:
        c.Cblock(self._GenerateFunctionParamsCreateWithExpected(function))

    # Results::Create function
    if function.returns_async:
      c.Concat(
          self._GenerateAsyncResponseArguments('Results',
                                               function.returns_async.params))

    c.Append('}  // namespace %s' % function_namespace)
    return c

  def _GenerateEvent(self, event):
    # TODO(kalman): use event.unix_name not Classname.
    c = Code()
    event_namespace = cpp_util.Classname(event.name)
    (c.Append('namespace %s {' % event_namespace) \
      .Append() \
      .Cblock(self._GenerateEventNameConstant(event)) \
      .Cblock(self._GenerateAsyncResponseArguments(None, event.params)) \
      .Append('}  // namespace %s' % event_namespace)
    )
    return c

  def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
    """Creates a base::Value given a type.

    var: variable or variable*

    E.g for std::string, generate new base::Value(var)
    """
    c = Code()
    underlying_type = self._type_helper.FollowRef(type_)
    if underlying_type.property_type == PropertyType.ARRAY:
      # Enums are treated specially because C++ templating thinks that they're
      # ints, but really they're strings. So we create a vector of strings and
      # populate it with the names of the enum in the array. The |ToString|
      # function of the enum can be in another namespace when the enum is
      # referenced. Templates can not be used here because C++ templating does
      # not support passing a namespace as an argument.
      item_type = self._type_helper.FollowRef(underlying_type.item_type)
      if item_type.property_type == PropertyType.ENUM:
        varname = ('*' if is_ptr else '') + '(%s)' % var

        maybe_namespace = ''
        if type_.item_type.property_type == PropertyType.REF:
          maybe_namespace = '%s::' % item_type.namespace.unix_name

        enum_list_var = '%s_list' % prop_name
        # Scope the std::vector variable declaration inside braces.
        (c.Sblock('{') \
          .Append('std::vector<std::string> %s;' % enum_list_var) \
          .Sblock('for (const auto& it : %s) {' % varname) \
            .Append('%s.emplace_back(%sToString(it));' % (enum_list_var,
                                                          maybe_namespace)) \
          .Eblock('}'))

        # Because the std::vector above is always created for both required and
        # optional enum arrays, |is_ptr| is set to false and uses the
        # std::vector to create the values.
        (c.Append(code %
            self._GenerateCreateValueFromType(type_, enum_list_var, False)) \
          .Eblock('}'))
        return c

    c.Append(code % self._GenerateCreateValueFromType(type_, var, is_ptr))
    return c

  def _GenerateCreateValueFromType(self, type_, var, is_ptr):
    """Generates the statement to create a base::Value given a type.

    type_:  The type of the values being converted.
    var:    The name of the variable.
    is_ptr: Whether |type_| is optional.
    """
    underlying_type = self._type_helper.FollowRef(type_)
    if (underlying_type.property_type == PropertyType.CHOICES
        or underlying_type.property_type == PropertyType.OBJECT):
      if is_ptr:
        return '(%s)->ToValue()' % var
      else:
        return '(%s).ToValue()' % var
    elif (underlying_type.property_type == PropertyType.ANY
          or (underlying_type.property_type == PropertyType.FUNCTION
              and not underlying_type.is_serializable_function)):
      if is_ptr:
        vardot = '(%s)->' % var
      else:
        vardot = '(%s).' % var
      return '%sClone()' % vardot
    elif underlying_type.property_type == PropertyType.ENUM:
      maybe_namespace = ''
      if type_.property_type == PropertyType.REF:
        maybe_namespace = '%s::' % underlying_type.namespace.unix_name
      return '%sToString(%s)' % (maybe_namespace, var)
    elif underlying_type.property_type == PropertyType.BINARY:
      if is_ptr:
        var = '*%s' % var
      return 'base::Value(%s)' % var
    elif underlying_type.property_type == PropertyType.ARRAY:
      if is_ptr:
        var = '*%s' % var
      underlying_item_cpp_type = (self._type_helper.GetCppType(
          underlying_type.item_type))
      if underlying_item_cpp_type != 'base::Value':
        return '%s' % self._util_cc_helper.CreateValueFromArray(var)
      else:
        return '(%s).Clone()' % var
    elif (underlying_type.property_type.is_fundamental
          or underlying_type.is_serializable_function):
      if is_ptr:
        var = '*%s' % var
      return '%s' % var
    else:
      raise NotImplementedError('Conversion of %s to base::Value not '
                                'implemented' % repr(type_.type_))

  def _GenerateParamsCheck(self, function, var, failure_value):
    """Generates a check for the correct number of arguments when creating
    Params.
    """
    c = Code()
    num_required = 0
    for param in function.params:
      if not param.optional:
        num_required += 1
    if num_required == len(function.params):
      c.Sblock('if (%(var)s.size() != %(total)d) {')
    elif not num_required:
      c.Sblock('if (%(var)s.size() > %(total)d) {')
    else:
      c.Sblock('if (%(var)s.size() < %(required)d'
               ' || %(var)s.size() > %(total)d) {')
    (c.Concat(self._AppendError16(
        'u"expected %%(total)d arguments, got " '
        '+ base::NumberToString16(%%(var)s.size())')) \
      .Append('return %(failure_value)s;') \
      .Eblock('}') \
      .Substitute({
        'var': var,
        'failure_value': failure_value,
        'required': num_required,
        'total': len(function.params),
    }))
    return c

  def _GenerateFunctionParamsCreate(self, function):
    """Generate function to create an instance of Params. The generated
    function takes a const base::Value::List& of arguments.

    E.g for function "Bar", generate Bar::Params::Create()
    """
    c = Code()

    (c.Append('// static') \
      .Sblock('std::optional<Params> Params::Create(%s) {' %
                  self._GenerateParams([
                      'const base::Value::List& args']))
    )

    failure_value = 'std::nullopt'
    (c.Concat(self._GenerateParamsCheck(function, 'args', failure_value)) \
      .Append('Params params;')
    )

    for param in function.params:
      c.Concat(self._InitializePropertyToDefault(param, 'params'))

    for i, param in enumerate(function.params):
      # Any failure will cause this function to return. If any argument is
      # incorrect or missing, those following it are not processed. Note that
      # for optional arguments, we allow missing arguments and proceed because
      # there may be other arguments following it.
      c.Append()
      value_var = param.unix_name + '_value'
      (c.Append('if (%(i)s < args.size() &&') \
        .Sblock('    !args[%(i)s].is_none()) {') \
        .Append('const base::Value& %(value_var)s = args[%(i)s];') \
        .Concat(self._GeneratePopulatePropertyFromValue(
            param, value_var, 'params', failure_value)) \
        .Eblock('}')
      )
      if not param.optional:
        (c.Sblock('else {') \
          .Concat(self._AppendError16('u"\'%%(key)s\' is required"')) \
          .Append('return %s;' % failure_value) \
          .Eblock('}'))
      c.Substitute({'value_var': value_var, 'i': i, 'key': param.name})
    (c.Append() \
      .Append('return params;') \
      .Eblock('}') \
      .Append()
    )

    return c

  def _GenerateFunctionParamsCreateWithExpected(self, function):
    """An overloaded added to `Create()` communinicating errors through
    `base::expected`.
    """
    # TODO(crbug.com/40256450): This function is being temporarily added
    # separately to allow us to migrate the places where error is being passed
    # as an out param. Once that is done, this duplication should be deleted,
    # and everything should be handled by a single Create function.
    c = Code()

    (c.Append('// static') \
      .Sblock('base::expected<Params, std::u16string> '
          'Params::Create(const base::Value::List& args) {')
    )

    (c.Append('std::u16string error;') \
      .Append('auto result = Params::Create(args, error);') \
      .Sblock('if (!result) {') \
        .Append('DCHECK(!error.empty());') \
        .Append('return base::unexpected(std::move(error));') \
      .Eblock('}') \
      .Append('return std::move(result).value();') \
      .Eblock('}') \
      .Append())
    return c

  def _GeneratePopulatePropertyFromValue(self, prop, src_var, dst_class_var,
                                         failure_value):
    """Generates code to populate property |prop| of |dst_class_var| (a
    pointer) from a Value. See |_GeneratePopulateVariableFromValue| for
    semantics.
    """
    return self._GeneratePopulateVariableFromValue(
        prop.type_,
        src_var,
        '%s.%s' % (dst_class_var, prop.unix_name),
        failure_value,
        is_ptr=prop.optional)

  def _GeneratePopulateVariableFromValue(self,
                                         type_,
                                         src_var,
                                         dst_var,
                                         failure_value,
                                         is_ptr=False):
    """Generates code to populate a variable |dst_var| of type |type_| from a
    Value |src_var|. In the generated code, if |dst_var| fails to be populated
    then Populate will return |failure_value|.
    """
    c = Code()

    underlying_type = self._type_helper.FollowRef(type_)

    if (underlying_type.property_type.is_fundamental
        or underlying_type.is_serializable_function):
      is_string_or_function = (
          underlying_type.property_type == PropertyType.STRING
          or (underlying_type.property_type == PropertyType.FUNCTION
              and underlying_type.is_serializable_function))
      c.Append('auto%s temp = %s;' %
               ('*' if is_string_or_function else '',
                cpp_util.GetAsFundamentalValue(underlying_type, src_var)))
      if is_string_or_function:
        (c.Sblock('if (!temp) {') \
          .Concat(self._AppendError16(
            'u"\'%%(key)s\': expected ' + '%s, got " + %s' % (
                type_.name,
                self._util_cc_helper.GetValueTypeString('%%(src_var)s')))))
      else:
        (c.Sblock('if (!temp.has_value()) {') \
          .Concat(self._AppendError16(
            'u"\'%%(key)s\': expected ' + '%s, got " + %s' % (
                type_.name,
                self._util_cc_helper.GetValueTypeString('%%(src_var)s')))))
      if is_ptr:
        if cpp_util.ShouldUseStdOptional(underlying_type):
          c.Append('%(dst_var)s = std::nullopt;')
        else:
          c.Append('%(dst_var)s.reset();')
      c.Append('return %(failure_value)s;')
      (c.Eblock('}'))
      if is_ptr:
        if cpp_util.ShouldUseStdOptional(underlying_type):
          c.Append('%(dst_var)s = *temp;')
        elif is_string_or_function:
          c.Append('%(dst_var)s = std::make_unique<%(cpp_type)s>(*temp);')
        else:
          c.Append('%(dst_var)s = ' +
                   'std::make_unique<%(cpp_type)s>(temp.value());')
      else:
        c.Append('%(dst_var)s = *temp;')
    elif underlying_type.property_type == PropertyType.OBJECT:
      if is_ptr:
        (c.Sblock('if (!%(src_var)s.is_dict()) {') \
          .Concat(self._AppendError16(
            'u"\'%%(key)s\': expected dictionary, got " + ' +
            self._util_cc_helper.GetValueTypeString('%%(src_var)s'))) \
          .Append('return %(failure_value)s;')
        )
        (c.Eblock('}') \
          .Sblock('else {') \
          .Append('%(cpp_type)s temp;') \
          .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
              ('%(src_var)s.GetDict()', 'temp'))) \
          .Append('  return %(failure_value)s;') \
          .Append('%(dst_var)s = std::move(temp);') \
          .Eblock('}')
        )
      else:
        (c.Sblock('if (!%(src_var)s.is_dict()) {') \
          .Concat(self._AppendError16(
            'u"\'%%(key)s\': expected dictionary, got " + ' +
            self._util_cc_helper.GetValueTypeString('%%(src_var)s'))) \
          .Append('return %(failure_value)s;') \
          .Eblock('}') \
          .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
            ('%(src_var)s.GetDict()', '%(dst_var)s'))) \
          .Append('  return %(failure_value)s;') \
          .Append('}')
        )
    elif underlying_type.property_type == PropertyType.FUNCTION:
      assert not underlying_type.is_serializable_function, \
          'Serializable functions should have been handled above.'
      # Non-serializable functions are just represented as empty dicts. If it
      # was optional we call emplace to construct it in-place, otherwise we just
      # check we were passed an empty dict.
      if is_ptr:
        c.Append('%(dst_var)s.emplace();')
      else:
        (c.Sblock('if (!%(src_var)s.is_dict() || ' +
                  '!%(src_var)s.GetDict().empty()) {') \
          .Concat(self._AppendError16(
            'u"\'%%(key)s\': expected dictionary, got " + ' +
            self._util_cc_helper.GetValueTypeString('%%(src_var)s'))) \
          .Append('return %(failure_value)s;') \
          .Eblock('}')
        )
    elif underlying_type.property_type == PropertyType.ANY:
      c.Append('%(dst_var)s = %(src_var)s.Clone();')
    elif underlying_type.property_type == PropertyType.ARRAY:
      # util_cc_helper deals with optional and required arrays
      (c.Sblock('if (!%(src_var)s.is_list()) {') \
        .Concat(self._AppendError16(
          'u"\'%%(key)s\': expected list, got " + ' +
          self._util_cc_helper.GetValueTypeString('%%(src_var)s'))) \
        .Append('return %(failure_value)s;')
      )
      c.Eblock('}')
      c.Sblock('else {')
      item_type = self._type_helper.FollowRef(underlying_type.item_type)
      if item_type.property_type == PropertyType.ENUM:
        c.Concat(
            self._GenerateListValueToEnumArrayConversion(item_type,
                                                         src_var,
                                                         dst_var,
                                                         failure_value,
                                                         is_ptr=is_ptr))
      else:
        args = ['%(src_var)s.GetList()', '%(dst_var)s']
        if self._generate_error_messages:
          c.Append('std::u16string array_parse_error;')
          args.append('array_parse_error')

        item_cpp_type = self._type_helper.GetCppType(item_type)
        if item_cpp_type != 'base::Value':
          c.Append('if (!%s(%s)) {' %
                   (self._util_cc_helper.PopulateArrayFromListFunction(is_ptr),
                    self._GenerateArgs(args, generate_error_messages=False)))
          c.Sblock()
          if self._generate_error_messages:
            c.Append('array_parse_error = u"Error at key \'%(key)s\': " + '
                     'array_parse_error;')
            c.Concat(self._AppendError16('array_parse_error'))
          c.Append('return %(failure_value)s;')
          c.Eblock('}')
        else:
          c.Append('%(dst_var)s = %(src_var)s.GetList().Clone();')
      c.Eblock('}')
    elif underlying_type.property_type == PropertyType.CHOICES:
      if is_ptr:
        (c.Append('%(cpp_type)s temp;') \
          .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
              ('%(src_var)s', 'temp'))) \
          .Append('  return %(failure_value)s;') \
          .Append('%(dst_var)s = std::move(temp);')
        )
      else:
        (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
            ('%(src_var)s', '%(dst_var)s'))) \
          .Append('  return %(failure_value)s;'))
    elif underlying_type.property_type == PropertyType.ENUM:
      c.Concat(
          self._GenerateStringToEnumConversion(underlying_type, src_var,
                                               dst_var, failure_value))
    elif underlying_type.property_type == PropertyType.BINARY:
      (c.Sblock('if (!%(src_var)s.is_blob()) {') \
        .Concat(self._AppendError16(
          'u"\'%%(key)s\': expected binary, got " + ' +
          self._util_cc_helper.GetValueTypeString('%%(src_var)s'))) \
        .Append('return %(failure_value)s;')
      )
      (c.Eblock('}') \
        .Sblock('else {')
      )
      c.Append('%(dst_var)s = %(src_var)s.GetBlob();')
      c.Eblock('}')
    else:
      raise NotImplementedError(type_)
    if c.IsEmpty():
      return c
    return Code().Sblock('{').Concat(
        c.Substitute({
            'cpp_type': self._type_helper.GetCppType(type_),
            'src_var': src_var,
            'dst_var': dst_var,
            'failure_value': failure_value,
            'key': type_.name,
            'parent_key': type_.parent.name,
        })).Eblock('}')

  def _GenerateListValueToEnumArrayConversion(self,
                                              item_type,
                                              src_var,
                                              dst_var,
                                              failure_value,
                                              is_ptr=False):
    """Returns Code that converts a list Value of string constants from
    |src_var| into an array of enums of |type_| in |dst_var|. On failure,
    returns |failure_value|.
    """
    c = Code()
    accessor = '.'
    if is_ptr:
      accessor = '->'
      cpp_type = self._type_helper.GetCppType(item_type)
      c.Append('%s.emplace();' % dst_var)
    (c.Sblock('for (const auto& it : (%s).GetList()) {' % src_var) \
      .Append('%s tmp;' % self._type_helper.GetCppType(item_type)) \
      .Concat(self._GenerateStringToEnumConversion(item_type,
                                                   '(it)',
                                                   'tmp',
                                                   failure_value)) \
      .Append('%s%spush_back(tmp);' % (dst_var, accessor)) \
      .Eblock('}')
    )
    return c

  def _GenerateStringToEnumConversion(self, type_, src_var, dst_var,
                                      failure_value):
    """Returns Code that converts a string type in |src_var| to an enum with
    type |type_| in |dst_var|. In the generated code, if |src_var| is not
    a valid enum name then the function will return |failure_value|.
    """
    if type_.property_type != PropertyType.ENUM:
      raise TypeError(type_)
    c = Code()
    enum_as_string = '%s_as_string' % type_.unix_name
    cpp_type_namespace = ''
    if type_.namespace != self._namespace:
      namespace = cpp_util.GetCppNamespace(
          type_.namespace.environment.namespace_pattern,
          type_.namespace.unix_name)
      cpp_type_namespace = '%s::' % namespace
    (c.Append('const std::string* %s = %s.GetIfString();' % (enum_as_string,
                                                            src_var)) \
      .Sblock('if (!%s) {' % enum_as_string) \
      .Concat(self._AppendError16(
        'u"\'%%(key)s\': expected string, got " + ' +
        self._util_cc_helper.GetValueTypeString('%%(src_var)s'))) \
      .Append('return %s;' % failure_value) \
      .Eblock('}') \
      .Append('%s = %sParse%s(*%s);' % (dst_var,
                                       cpp_type_namespace,
                                       cpp_util.Classname(type_.name),
                                       enum_as_string)) \
      .Sblock('if (%s == %s) {' % (dst_var,
                        self._type_helper.GetEnumDefaultValue(type_,
                          self._namespace))) \
      .Concat(self._AppendError16(
        'u\"\'%%(key)s\': "' + (
            ' + %sGet%sParseError(*%s)' %
            (cpp_type_namespace,
             cpp_util.Classname(type_.name),
             enum_as_string)))) \
      .Append('return %s;' % failure_value) \
      .Eblock('}') \
      .Substitute({'src_var': src_var, 'key': type_.name})
    )
    return c

  def _GeneratePropertyFunctions(self, namespace, params):
    """Generates the member functions for a list of parameters.
    """
    return self._GenerateTypes(namespace, (param.type_ for param in params))

  def _GenerateTypes(self, namespace, types):
    """Generates the member functions for a list of types.
    """
    c = Code()
    for type_ in types:
      c.Cblock(self._GenerateType(namespace, type_))
    return c

  def _GenerateEnumToString(self, cpp_namespace, type_):
    """Generates ToString() which gets the string representation of an enum.
    """
    c = Code()
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))

    if cpp_namespace is not None:
      c.Append('// static')
    maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace

    c.Sblock('const char* %sToString(%s enum_param) {' %
             (maybe_namespace, classname))
    c.Sblock('switch (enum_param) {')
    for enum_value in self._type_helper.FollowRef(type_).enum_values:
      name = enum_value.name
      (c.Append('case %s: ' %
                self._type_helper.GetEnumValue(type_, enum_value)) \
        .Append('  return "%s";' % name))
    (c.Append('case %s:' % self._type_helper.GetEnumNoneValue(type_)) \
      .Append('  return "";') \
      .Eblock('}') \
      .Append('NOTREACHED();') \
      .Eblock('}')
    )
    return c

  def _GenerateEnumFromString(self, cpp_namespace, type_):
    """Generates FromClassNameString() which gets an enum from its string
    representation.
    """
    c = Code()
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))

    if cpp_namespace is not None:
      c.Append('// static')
    maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace

    c.Sblock('%s%s %sParse%s(std::string_view enum_string) {' %
             (maybe_namespace, classname, maybe_namespace, classname))
    for _, enum_value in enumerate(
        self._type_helper.FollowRef(type_).enum_values):
      # This is broken up into all ifs with no else ifs because we get
      # "fatal error C1061: compiler limit : blocks nested too deeply"
      # on Windows.
      name = enum_value.name
      (c.Append('if (enum_string == "%s")' % name) \
        .Append('  return %s;' %
            self._type_helper.GetEnumValue(type_, enum_value)))
    (c.Append('return %s;' % self._type_helper.GetEnumNoneValue(type_)) \
      .Eblock('}')
    )
    return c

  def _GenerateEnumParseErrorMessage(self, cpp_namespace, type_):
    """Generates Get<ClassName>ParseError() which returns a parse error message
    for a given string input.
    """

    c = Code()
    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))

    if cpp_namespace is not None:
      c.Append('// static')
    maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace

    c.Sblock(
        'std::u16string %sGet%sParseError(std::string_view enum_string) {' %
        (maybe_namespace, classname))
    error_message = ('u\"expected \\"' + '\\" or \\"'.join(
        enum_value.name
        for enum_value in self._type_helper.FollowRef(type_).enum_values) +
                     '\\", got \\"" + UTF8ToUTF16(enum_string) + u"\\""')
    c.Append('return %s;' % error_message)
    c.Eblock('}')
    return c

  def _GenerateAsyncResponseArguments(self, function_scope, params):
    """Generate the function that creates base::Value parameters to return to a
    callback, promise or pass to an event listener.

    E.g for function "Bar", generate Bar::Results::Create
    E.g for event "Baz", generate Baz::Create

    function_scope: the function scope path, e.g. Foo::Bar for the function
                    Foo::Bar::Baz(). May be None if there is no function scope.
    params: the parameters passed as results or event details.
    """
    c = Code()
    c.Concat(self._GeneratePropertyFunctions(function_scope, params))

    (c.Sblock('base::Value::List %(function_scope)s'
                  'Create(%(declaration_list)s) {') \
      .Append('base::Value::List create_results;') \
      .Append('create_results.reserve(%d);' % len(params) if len(params)
              else '')
    )
    declaration_list = []
    for param in params:
      declaration_list.append(
          cpp_util.GetParameterDeclaration(
              param, self._type_helper.GetCppType(param.type_)))
      c.Cblock(
          self._CreateValueFromType('create_results.Append(%s);', param.name,
                                    param.type_, param.unix_name))
    c.Append('return create_results;')
    c.Eblock('}')
    c.Substitute({
        'function_scope': ('%s::' % function_scope) if function_scope else '',
        'declaration_list':
        ', '.join(declaration_list),
        'param_names':
        ', '.join(param.unix_name for param in params)
    })
    return c

  def _GenerateEventNameConstant(self, event):
    """Generates a constant string array for the event name.
    """
    c = Code()
    c.Append('const char kEventName[] = "%s.%s";' %
             (self._namespace.name, event.name))
    return c

  def _InitializePropertyToDefault(self, prop, dst):
    """Initialize a model.Property to its default value inside an object.

    E.g for optional enum "state", generate dst.state = STATE_NONE;

    dst: Type
    """
    c = Code()
    underlying_type = self._type_helper.FollowRef(prop.type_)
    if (underlying_type.property_type == PropertyType.ENUM and prop.optional):
      c.Append('%s.%s = %s;' % (dst, prop.unix_name,
                                self._type_helper.GetEnumDefaultValue(
                                    underlying_type, self._namespace)))
    return c

  def _AppendError16(self, error16):
    """Appends the given |error16| expression/variable to |error|.
    """
    c = Code()
    if not self._generate_error_messages:
      return c
    c.Append('DCHECK(error.empty());')
    c.Append('error = %s;' % error16)
    return c

  def _GenerateParams(self, params, generate_error_messages=None):
    """Builds the parameter list for a function, given an array of parameters.
    If |generate_error_messages| is specified, it overrides
    |self._generate_error_messages|.
    """
    if generate_error_messages is None:
      generate_error_messages = self._generate_error_messages
    if generate_error_messages:
      params = list(params) + ['std::u16string& error']
    return ', '.join(str(p) for p in params)

  def _GenerateArgs(self, args, generate_error_messages=None):
    """Builds the argument list for a function, given an array of arguments.
    If |generate_error_messages| is specified, it overrides
    |self._generate_error_messages|.
    """
    if generate_error_messages is None:
      generate_error_messages = self._generate_error_messages
    if generate_error_messages:
      args = list(args) + ['error']
    return ', '.join(str(a) for a in args)