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

import("//build/config/jumbo.gni")

# TODO(rockot): Maybe we can factor these dependencies out of //mojo. They're
# used to conditionally enable message ID scrambling in a way which is
# consistent across toolchains and which is affected by branded vs non-branded
# Chrome builds. Ideally we could create some generic knobs here that could be
# flipped elsewhere though.
import("//build/config/chrome_build.gni")
import("//build/config/nacl/config.gni")
import("//components/nacl/features.gni")

declare_args() {
  # Indicates whether typemapping should be supported in this build
  # configuration. This may be disabled when building external projects which
  # depend on //mojo but which do not need/want all of the Chromium tree
  # dependencies that come with typemapping.
  #
  # Note that (perhaps obviously) a huge amount of Chromium code will not build
  # with typemapping disabled, so it is never valid to set this to |false| in
  # any Chromium build configuration.
  enable_mojom_typemapping = true
}

# NOTE: We would like to avoid scrambling message IDs where it doesn't add
# value, so we limit the behavior to desktop builds for now. There is some
# redundancy in the conditions here, but it is tolerated for clarity:
# We're explicit about Mac, Windows, and Linux desktop support, but it's
# also necessary to ensure that bindings in alternate toolchains (e.g.
# NaCl IRT) are always consistent with the default toolchain; for that
# reason we always enable scrambling within NaCl toolchains when possible,
# as well as within the default toolchain when NaCl is enabled.
#
# Finally, because we *cannot* enable scrambling on Chrome OS (it would break
# ARC) we have to explicitly opt out there even when NaCl is enabled (and
# consequently also when building for NaCl toolchains.) For this reason we
# check |target_os| explicitly, as it's consistent across all toolchains.
enable_scrambled_message_ids =
    is_mac || is_win || (is_linux && !is_chromeos) ||
    ((enable_nacl || is_nacl || is_nacl_nonsfi) && target_os != "chromeos")

mojom_generator_root = "//mojo/public/tools/bindings"
mojom_generator_script = "$mojom_generator_root/mojom_bindings_generator.py"
mojom_generator_sources = [
  "$mojom_generator_root/generators/mojom_cpp_generator.py",
  "$mojom_generator_root/generators/mojom_js_generator.py",
  "$mojom_generator_root/generators/mojom_java_generator.py",
  "$mojom_generator_root/pylib/mojom/__init__.py",
  "$mojom_generator_root/pylib/mojom/error.py",
  "$mojom_generator_root/pylib/mojom/generate/__init__.py",
  "$mojom_generator_root/pylib/mojom/generate/constant_resolver.py",
  "$mojom_generator_root/pylib/mojom/generate/generator.py",
  "$mojom_generator_root/pylib/mojom/generate/module.py",
  "$mojom_generator_root/pylib/mojom/generate/pack.py",
  "$mojom_generator_root/pylib/mojom/generate/template_expander.py",
  "$mojom_generator_root/pylib/mojom/generate/translate.py",
  "$mojom_generator_root/pylib/mojom/parse/__init__.py",
  "$mojom_generator_root/pylib/mojom/parse/ast.py",
  "$mojom_generator_root/pylib/mojom/parse/lexer.py",
  "$mojom_generator_root/pylib/mojom/parse/parser.py",
  "$mojom_generator_script",
]

if (enable_scrambled_message_ids) {
  declare_args() {
    # The path to a file whose contents can be used as the basis for a message
    # ID scrambling salt.
    mojom_message_id_salt_path = "//chrome/VERSION"

    # The path to a file whose contents will be concatenated to the contents of
    # the file at |mojom_message_id_salt_path| to form a complete salt for
    # message ID scrambling. May be the empty string, in which case the contents
    # of the above file alone are used as the complete salt.
    if (is_chrome_branded) {
      mojom_message_id_salt_suffix_path =
          "//mojo/internal/chrome-message-id-salt-suffix"
    } else {
      mojom_message_id_salt_suffix_path = ""
    }
  }

  mojom_generator_sources += [ mojom_message_id_salt_path ]
  if (mojom_message_id_salt_suffix_path != "") {
    mojom_generator_sources += [ mojom_message_id_salt_suffix_path ]
  }
}

generate_export_header_script =
    "$mojom_generator_root/generate_export_header.py"

if (enable_mojom_typemapping) {
  if (!is_ios) {
    _bindings_configuration_files = [
      "//mojo/public/tools/bindings/chromium_bindings_configuration.gni",
      "//mojo/public/tools/bindings/blink_bindings_configuration.gni",
    ]
  } else {
    _bindings_configuration_files =
        [ "//mojo/public/tools/bindings/chromium_bindings_configuration.gni" ]
  }
  _bindings_configurations = []
  foreach(config_file, _bindings_configuration_files) {
    _bindings_configurations += [ read_file(config_file, "scope") ]
  }
  foreach(configuration, _bindings_configurations) {
    # Check that the mojom field of each typemap refers to a mojom that exists.
    foreach(typemap, configuration.typemaps) {
      _typemap_config = {
      }
      _typemap_config = typemap.config
      read_file(_typemap_config.mojom, "")
    }
    if (is_mac && defined(configuration.typemaps_mac)) {
      foreach(typemap, configuration.typemaps_mac) {
        _typemap_config = {
        }
        _typemap_config = typemap.config
        read_file(_typemap_config.mojom, "")
      }
    } else if (is_chromeos && defined(configuration.typemaps_chromeos)) {
      foreach(typemap, configuration.typemaps_chromeos) {
        _typemap_config = {
        }
        _typemap_config = typemap.config
        read_file(_typemap_config.mojom, "")
      }
    }
  }
} else {
  _bindings_configuration_files = []
  _bindings_configurations = [
    {
      typemaps = []
      component_macro_suffix = ""
    },
    {
      variant = "blink"
      component_macro_suffix = "_BLINK"
      for_blink = true
      typemaps = []
    },
  ]
}

# Generates targets for building C++, JavaScript and Java bindings from mojom
# files. The output files will go under the generated file directory tree with
# the same path as each input file.
#
# Other targets should depend on one of these generated targets (where "foo"
# is the target name):
#
#   foo
#       C++ bindings.
#
#   foo_blink
#       C++ bindings using Blink standard types.
#
#   foo_java
#       Java bindings.
#
#   foo_js
#       JavaScript bindings; used as compile-time dependency.
#
#   foo_js_data_deps
#       JavaScript bindings; used as run-time dependency.
#
# Parameters:
#
#   sources (optional if one of the deps sets listed below is present)
#       List of source .mojom files to compile.
#
#   deps (optional)
#       Note: this can contain only other mojom targets.
#
#       DEPRECATED: This is synonymous with public_deps because all mojom
#       dependencies must be public by design. Please use public_deps.
#
#   public_deps (optional)
#       Note: this can contain only other mojom targets.
#
#   import_dirs (optional)
#       List of import directories that will get added when processing sources.
#
#   testonly (optional)
#
#   visibility (optional)
#
#   visibility_blink (optional)
#       The value to use for visibility for the blink variant. If unset,
#       |visibility| is used.
#
#   use_once_callback (optional)
#       If set to true, generated classes will use base::OnceCallback instead of
#       base::RepeatingCallback.
#       Default value is true.
#       TODO(dcheng):
#           - Convert everything to use OnceCallback.
#           - Remove support for the old mode.
#
#   cpp_only (optional)
#       If set to true, only the C++ bindings targets will be generated.
#
#   use_new_js_bindings (optional)
#       If set to true, the generated JS code will use the new module loading
#       approach and the core API exposed by Web IDL.
#       Default value is true.
#       TODO(yzshen): Convert all users to use new JS bindings and remove the
#       old mode.
#
#   js_bindings_mode (optional)
#       |js_bindings_mode| and |use_new_js_bindings| are mutually exclusive. You
#       can only specify at most one of them.
#       - "new" (default): generate only the new-style JS bindings;
#       - "both": generate both the old- and new-style JS bindings;
#       - "old": generate only the old-style JS bindings.
#       TODO(yzshen): Convert all users to use new JS bindings and remove the
#       old mode.
#
#   support_lazy_serialization (optional)
#       If set to |true|, generated C++ bindings will effectively prefer to
#       transmit messages in an unserialized form when going between endpoints
#       in the same process. This avoids the runtime cost of serialization,
#       deserialization, and validation logic at the expensive of increased
#       code size. Defaults to |false|.
#
#   disable_variants (optional)
#       If |true|, no variant sources will be generated for the target. Defaults
#       to |false|.
#
#   allow_native_structs (optional)
#       If set to |true| (the default), mojoms in this target may apply the
#       [Native] attribute to struct declarations, causing that mojom struct to
#       be serialized and deserialized using a legacy IPC::ParamTraits
#       specialization.
#
#   scramble_message_ids (optional)
#       If set to |true| (the default), generated mojom interfaces will use
#       scrambled ordinal identifiers in encoded messages.
#
#   component_output_prefix (optional)
#       The prefix to use for the output_name of any component library emitted
#       for generated C++ bindings. If this is omitted, C++ bindings targets are
#       emitted as source_sets instead. Because this controls the name of the
#       output shared library binary in the root output directory, it must be
#       unique across the entire build configuration.
#
#       This is required if |component_macro_prefix| is specified.
#
#   component_macro_prefix (optional)
#       This specifies a macro prefix to use for component export macros and
#       should therefore be globally unique in the project. For example if this
#       is "FOO_BAR", then the generated C++ sources will be built with
#       FOO_BAR_IMPL defined, and the generated public headers will affix
#       FOO_BAR_EXPORT to all public symbol definitions; the meaning of the
#       EXPORT macro depends on whether the corresponding IMPL macro is defined,
#       per standard practice with Chromium component exports.
#
# The following parameters are used to support the component build. They are
# needed so that bindings which are linked with a component can use the same
# export settings for classes. The first three are for the chromium variant, and
# the last three are for the blink variant. These parameters are mutually
# exclusive to |component_macro_prefix|, but |component_output_prefix| may still
# be used to uniqueify the generated invariant (i.e. shared) output component.
#   export_class_attribute (optional)
#       The attribute to add to the class declaration. e.g. "CONTENT_EXPORT"
#   export_define (optional)
#       A define to be added to the source_set which is needed by the export
#       header. e.g. "CONTENT_IMPLEMENTATION=1"
#   export_header (optional)
#       A header to be added to the generated bindings to support the component
#       build. e.g. "content/common/content_export.h"
#   export_class_attribute_blink (optional)
#   export_define_blink (optional)
#   export_header_blink (optional)
#       These three parameters are the blink variants of the previous 3.
#
# The following parameters are used to correct component build dependencies.
# They are needed so mojom-mojom dependencies follow the rule that dependencies
# on a source set in another component are replaced by a dependency on the
# containing component. The first two are for the chromium variant; the other
# two are for the blink variant.
#   overridden_deps (optional)
#       The list of mojom deps to be overridden.
#   component_deps (optional)
#       The list of component deps to add to replace overridden_deps.
#   overridden_deps_blink (optional)
#   component_deps_blink (optional)
#       These two parameters are the blink variants of the previous two.
template("mojom") {
  assert(
      defined(invoker.sources) || defined(invoker.deps) ||
          defined(invoker.public_deps),
      "\"sources\" or \"deps\" must be defined for the $target_name template.")

  assert(!defined(invoker.use_new_js_bindings) ||
             !defined(invoker.js_bindings_mode),
         "You shouldn't specify both \"use_new_js_bindings\" and " +
             "\"js_bindings_mode\".")

  if (defined(invoker.export_class_attribute) ||
      defined(invoker.export_define) || defined(invoker.export_header)) {
    assert(defined(invoker.export_class_attribute))
    assert(defined(invoker.export_define))
    assert(defined(invoker.export_header))
    assert(!defined(invoker.component_macro_prefix))
  }
  if (defined(invoker.export_class_attribute_blink) ||
      defined(invoker.export_define_blink) ||
      defined(invoker.export_header_blink)) {
    assert(defined(invoker.export_class_attribute_blink))
    assert(defined(invoker.export_define_blink))
    assert(defined(invoker.export_header_blink))
    assert(!defined(invoker.component_macro_prefix))
  }
  if (defined(invoker.overridden_deps) || defined(invoker.component_deps)) {
    assert(defined(invoker.overridden_deps))
    assert(defined(invoker.component_deps))
  }

  if (defined(invoker.overridden_deps_blink) ||
      defined(invoker.component_deps_blink)) {
    assert(defined(invoker.overridden_deps_blink))
    assert(defined(invoker.component_deps_blink))
  }

  js_bindings_mode = "new"
  if (defined(invoker.js_bindings_mode)) {
    js_bindings_mode = invoker.js_bindings_mode
  }
  if (defined(invoker.use_new_js_bindings) && !invoker.use_new_js_bindings) {
    js_bindings_mode = "old"
  }
  assert(js_bindings_mode == "new" || js_bindings_mode == "both" ||
             js_bindings_mode == "old",
         "Invalid js_bindings_mode value.")

  all_deps = []
  if (defined(invoker.deps)) {
    all_deps += invoker.deps
  }
  if (defined(invoker.public_deps)) {
    all_deps += invoker.public_deps
  }

  if (defined(invoker.component_macro_prefix)) {
    assert(defined(invoker.component_output_prefix))
  }

  group("${target_name}__is_mojom") {
  }

  # Explicitly ensure that all dependencies (invoker.deps and
  # invoker.public_deps) are mojom targets.
  group("${target_name}__check_deps_are_all_mojom") {
    deps = []
    foreach(d, all_deps) {
      name = get_label_info(d, "label_no_toolchain")
      toolchain = get_label_info(d, "toolchain")
      deps += [ "${name}__is_mojom(${toolchain})" ]
    }
  }

  # Generate code that is shared by different variants.
  if (defined(invoker.sources)) {
    common_generator_args = [
      "--use_bundled_pylibs",
      "generate",
      "{{source}}",
      "-d",
      rebase_path("//", root_build_dir),
      "-I",
      rebase_path("//", root_build_dir),
      "-o",
      rebase_path(root_gen_dir, root_build_dir),
      "--bytecode_path",
      rebase_path("$root_gen_dir/mojo/public/tools/bindings", root_build_dir),
    ]

    if (!defined(invoker.scramble_message_ids) || invoker.scramble_message_ids) {
      # Scramble message IDs if enabled, unless the target has explicitly opted
      # out.
      if (enable_scrambled_message_ids) {
        assert(mojom_message_id_salt_path != "")
        common_generator_args += [
          "--scrambled_message_id_salt_path",
          rebase_path(mojom_message_id_salt_path, root_build_dir),
        ]

        if (mojom_message_id_salt_suffix_path != "") {
          common_generator_args += [
            "--scrambled_message_id_salt_path",
            rebase_path(mojom_message_id_salt_suffix_path, root_build_dir),
          ]
        }
      }
    }

    if (!defined(invoker.allow_native_structs) || invoker.allow_native_structs) {
      common_generator_args += [ "--allow_native_structs" ]
    }

    if (defined(invoker.import_dirs)) {
      foreach(import_dir, invoker.import_dirs) {
        common_generator_args += [
          "-I",
          rebase_path(import_dir, root_build_dir),
        ]
      }
    }

    if (defined(invoker.component_macro_prefix)) {
      shared_component_export_macro =
          "${invoker.component_macro_prefix}_SHARED_EXPORT"
      shared_component_impl_macro =
          "${invoker.component_macro_prefix}_SHARED_IMPL"
      shared_component_output_name = "${invoker.component_output_prefix}_shared"
    } else if (defined(invoker.export_class_attribute_shared) ||
               defined(invoker.export_class_attribute)) {
      if (defined(invoker.export_class_attribute_shared)) {
        assert(defined(invoker.export_header_shared))
        shared_component_export_macro = invoker.export_class_attribute_shared
        shared_component_impl_macro = invoker.export_define_shared
      } else {
        assert(!defined(invoker.export_header_shared))

        # If no explicit shared attribute/define was provided by the invoker,
        # we derive some reasonable settings frorm the default variant. A new
        # export header will be generated for these and used by shared code.
        shared_component_export_macro =
            "MOJOM_SHARED_" + invoker.export_class_attribute
        shared_component_impl_macro = "MOJOM_SHARED_" + invoker.export_define
      }

      if (defined(invoker.component_output_prefix)) {
        shared_component_output_name =
            "${invoker.component_output_prefix}_shared"
      } else {
        shared_component_output_name = "${target_name}_shared"
      }
    }

    if (defined(shared_component_export_macro) &&
        !defined(invoker.export_header_shared)) {
      generated_shared_export_header =
          rebase_path("${target_name}_shared_export.h", "", target_gen_dir)
      shared_export_header =
          rebase_path(generated_shared_export_header, root_gen_dir)
    } else if (defined(invoker.export_header_shared)) {
      shared_export_header = invoker.export_header_shared
    }

    generator_shared_cpp_outputs = [
      "{{source_gen_dir}}/{{source_name_part}}.mojom-shared-internal.h",
      "{{source_gen_dir}}/{{source_name_part}}.mojom-shared.cc",
      "{{source_gen_dir}}/{{source_name_part}}.mojom-shared.h",
    ]
    generator_shared_target_name = "${target_name}_shared__generator"
    action_foreach(generator_shared_target_name) {
      script = mojom_generator_script
      inputs = mojom_generator_sources
      sources = invoker.sources
      deps = [
        "//mojo/public/tools/bindings:precompile_templates",
      ]
      outputs = generator_shared_cpp_outputs
      args = common_generator_args
      args += [
        "--generate_non_variant_code",
        "-g",
        "c++",
      ]
      depfile = "{{source_gen_dir}}/${generator_shared_target_name}_{{source_name_part}}.d"
      args += [
        "--depfile",
        depfile,
        "--depfile_target",
        "{{source_gen_dir}}/{{source_name_part}}.mojom-shared-internal.h",
      ]

      if (defined(shared_component_export_macro)) {
        args += [
          "--export_attribute",
          shared_component_export_macro,
          "--export_header",
          shared_export_header,
        ]
      }
    }
  }

  if (defined(generated_shared_export_header)) {
    shared_export_generator_target_name =
        "${target_name}__generate_shared_export_header"
    action(shared_export_generator_target_name) {
      script = generate_export_header_script
      outputs = [
        get_path_info(generated_shared_export_header, "abspath"),
      ]
      args = [
        "--export_macro",
        shared_component_export_macro,
        "--impl_macro",
        shared_component_impl_macro,
        "--output_file",
        rebase_path(generated_shared_export_header, root_build_dir),
        "--relative_path",
        rebase_path(generated_shared_export_header, root_gen_dir),
      ]
    }
  }

  shared_cpp_sources_target_name = "${target_name}_shared_cpp_sources"
  jumbo_source_set(shared_cpp_sources_target_name) {
    if (defined(invoker.testonly)) {
      testonly = invoker.testonly
    }
    deps = []
    if (defined(invoker.sources)) {
      sources =
          process_file_template(invoker.sources, generator_shared_cpp_outputs)
      deps += [ ":$generator_shared_target_name" ]
    }
    public_deps = [
      "//mojo/public/cpp/bindings",
    ]
    foreach(d, all_deps) {
      # Resolve the name, so that a target //mojo/something becomes
      # //mojo/something:something and we can append shared_cpp_sources_suffix
      # to get the cpp dependency name.
      full_name = get_label_info("$d", "label_no_toolchain")
      public_deps += [ "${full_name}_shared" ]
    }
    if (defined(shared_component_impl_macro)) {
      defines = [ shared_component_impl_macro ]
    }
    if (defined(generated_shared_export_header)) {
      sources += [ get_path_info(generated_shared_export_header, "abspath") ]
      public_deps += [ ":$shared_export_generator_target_name" ]
    }
  }

  shared_cpp_library_target_name = "${target_name}_shared"
  if (defined(shared_component_output_name)) {
    component(shared_cpp_library_target_name) {
      if (defined(invoker.testonly)) {
        testonly = invoker.testonly
      }
      output_name = "$shared_component_output_name"
      public_deps = [
        ":$shared_cpp_sources_target_name",
      ]
    }
  } else {
    group(shared_cpp_library_target_name) {
      if (defined(invoker.testonly)) {
        testonly = invoker.testonly
      }
      public_deps = [
        ":$shared_cpp_sources_target_name",
      ]
    }
  }

  # Generate code for variants.
  if (!defined(invoker.disable_variants) || !invoker.disable_variants) {
    enabled_configurations = _bindings_configurations
  } else {
    first_config = _bindings_configurations[0]
    assert(!defined(first_config.variant))
    enabled_configurations = [ first_config ]
  }
  foreach(bindings_configuration, enabled_configurations) {
    cpp_only = false
    if (defined(invoker.cpp_only)) {
      cpp_only = invoker.cpp_only
    }
    variant_suffix = ""
    if (defined(bindings_configuration.variant)) {
      variant = bindings_configuration.variant
      variant_suffix = "_${variant}"
      cpp_only = true
    }
    type_mappings_target_name = "${target_name}${variant_suffix}__type_mappings"
    type_mappings_path =
        "$target_gen_dir/${target_name}${variant_suffix}__type_mappings"
    active_typemaps = []
    enabled_sources = []
    if (defined(invoker.sources)) {
      generator_cpp_outputs = []
      generator_java_outputs = []
      variant_dash_suffix = ""
      if (defined(variant)) {
        variant_dash_suffix = "-${variant}"
      }
      generator_cpp_outputs += [
        "{{source_gen_dir}}/{{source_name_part}}.mojom${variant_dash_suffix}.cc",
        "{{source_gen_dir}}/{{source_name_part}}.mojom${variant_dash_suffix}.h",
      ]
      enabled_sources = []
      if (defined(bindings_configuration.blacklist)) {
        foreach(source, invoker.sources) {
          blacklisted = false
          foreach(blacklisted_source, bindings_configuration.blacklist) {
            if (get_path_info(source, "abspath") == blacklisted_source) {
              blacklisted = true
            }
          }
          if (!blacklisted) {
            enabled_sources += [ source ]
          }
        }
      } else {
        enabled_sources = invoker.sources
      }
      foreach(source, enabled_sources) {
        # TODO(sammc): Use a map instead of a linear scan when GN supports maps.
        foreach(typemap, bindings_configuration.typemaps) {
          _typemap_config = {
          }
          _typemap_config = typemap.config
          if (get_path_info(source, "abspath") == _typemap_config.mojom) {
            active_typemaps += [ typemap ]
          }
        }
        if (is_mac && defined(bindings_configuration.typemaps_mac)) {
          foreach(typemap, bindings_configuration.typemaps_mac) {
            _typemap_config = {
            }
            _typemap_config = typemap.config
            if (get_path_info(source, "abspath") == _typemap_config.mojom) {
              active_typemaps += [ typemap ]
            }
          }
        } else if (is_chromeos &&
                   defined(bindings_configuration.typemaps_chromeos)) {
          foreach(typemap, bindings_configuration.typemaps_chromeos) {
            _typemap_config = {
            }
            _typemap_config = typemap.config
            if (get_path_info(source, "abspath") == _typemap_config.mojom) {
              active_typemaps += [ typemap ]
            }
          }
        }
      }

      if (defined(invoker.component_macro_prefix)) {
        export_header_generator_target_name =
            "${target_name}${variant_suffix}__generate_export_header"
        generated_export_header =
            rebase_path("${target_name}${variant_suffix}_export.h",
                        "",
                        target_gen_dir)
        action(export_header_generator_target_name) {
          script = generate_export_header_script
          outputs = [
            get_path_info(generated_export_header, "abspath"),
          ]
          args = [
            "--export_macro",
            "${invoker.component_macro_prefix}${bindings_configuration.component_macro_suffix}_EXPORT",
            "--impl_macro",
            "${invoker.component_macro_prefix}${bindings_configuration.component_macro_suffix}_IMPL",
            "--output_file",
            rebase_path(generated_export_header, root_build_dir),
            "--relative_path",
            rebase_path(generated_export_header, root_gen_dir),
          ]
        }
      }

      if (!cpp_only) {
        generator_java_outputs =
            [ "{{source_gen_dir}}/{{source_name_part}}.mojom.srcjar" ]
      }
      generator_target_name = "${target_name}${variant_suffix}__generator"
      action_foreach(generator_target_name) {
        script = mojom_generator_script
        inputs = mojom_generator_sources
        sources = invoker.sources
        deps = [
          ":$type_mappings_target_name",
          "//mojo/public/tools/bindings:precompile_templates",
        ]
        outputs = generator_cpp_outputs + generator_java_outputs
        args = common_generator_args

        if (cpp_only) {
          args += [
            "-g",
            "c++",
          ]
        } else {
          args += [
            "-g",
            "c++,java",
          ]
        }

        if (defined(bindings_configuration.variant)) {
          args += [
            "--variant",
            bindings_configuration.variant,
          ]
        }
        depfile =
            "{{source_gen_dir}}/${generator_target_name}_{{source_name_part}}.d"
        args += [
          "--depfile",
          depfile,
          "--depfile_target",
          "{{source_gen_dir}}/{{source_name_part}}.mojom${variant_dash_suffix}.cc",
        ]

        args += [
          "--typemap",
          rebase_path(type_mappings_path, root_build_dir),
        ]

        if (defined(invoker.component_macro_prefix)) {
          args += [
            "--export_attribute",
            "${invoker.component_macro_prefix}${bindings_configuration.component_macro_suffix}_EXPORT",
            "--export_header",
            rebase_path(generated_export_header, root_gen_dir),
          ]
        }

        if (defined(bindings_configuration.for_blink) &&
            bindings_configuration.for_blink) {
          args += [ "--for_blink" ]
          if (defined(invoker.export_class_attribute_blink)) {
            args += [
              "--export_attribute",
              invoker.export_class_attribute_blink,
              "--export_header",
              invoker.export_header_blink,
            ]
          }
        } else {
          if (defined(invoker.export_class_attribute)) {
            args += [
              "--export_attribute",
              invoker.export_class_attribute,
              "--export_header",
              invoker.export_header,
            ]
          }
        }

        if (!defined(invoker.use_once_callback) || invoker.use_once_callback) {
          args += [ "--use_once_callback" ]
        }

        if (defined(invoker.support_lazy_serialization) &&
            invoker.support_lazy_serialization) {
          args += [ "--support_lazy_serialization" ]
        }
      }
    }

    action(type_mappings_target_name) {
      inputs = _bindings_configuration_files
      outputs = [
        type_mappings_path,
      ]
      script = "$mojom_generator_root/generate_type_mappings.py"
      deps = []
      args = [
        "--output",
        rebase_path(type_mappings_path, root_build_dir),
      ]

      foreach(d, all_deps) {
        name = get_label_info(d, "label_no_toolchain")
        toolchain = get_label_info(d, "toolchain")
        dependency_output = "${name}${variant_suffix}__type_mappings"
        dependency_target = "${dependency_output}(${toolchain})"
        deps += [ dependency_target ]
        dependency_output_dir =
            get_label_info(dependency_output, "target_gen_dir")
        dependency_name = get_label_info(dependency_output, "name")
        dependency_path =
            rebase_path("$dependency_output_dir/${dependency_name}",
                        root_build_dir)
        args += [
          "--dependency",
          dependency_path,
        ]
      }

      if (enabled_sources != []) {
        # TODO(sammc): Pass the typemap description in a file to avoid command
        # line length limitations.
        typemap_description = []
        foreach(typemap, active_typemaps) {
          _typemap_config = {
          }
          _typemap_config = typemap.config
          typemap_description += [ "--start-typemap" ]
          if (defined(_typemap_config.public_headers)) {
            foreach(value, _typemap_config.public_headers) {
              typemap_description += [ "public_headers=$value" ]
            }
          }
          if (defined(_typemap_config.traits_headers)) {
            foreach(value, _typemap_config.traits_headers) {
              typemap_description += [ "traits_headers=$value" ]
            }
          }
          foreach(value, _typemap_config.type_mappings) {
            typemap_description += [ "type_mappings=$value" ]
          }

          # The typemap configuration files are not actually used as inputs here
          # but this establishes a necessary build dependency to ensure that
          # typemap changes force a rebuild of affected targets.
          inputs += [ typemap.filename ]
        }
        args += typemap_description
      }
    }

    if (defined(invoker.component_macro_prefix)) {
      output_target_type = "component"
    } else {
      output_target_type = "source_set"
    }

    target("jumbo_" + output_target_type, "${target_name}${variant_suffix}") {
      if (defined(bindings_configuration.for_blink) &&
          bindings_configuration.for_blink &&
          defined(invoker.visibility_blink)) {
        visibility = invoker.visibility_blink
      } else if (defined(invoker.visibility)) {
        visibility = invoker.visibility
      }
      if (defined(invoker.testonly)) {
        testonly = invoker.testonly
      }
      defines = []
      if (defined(invoker.testonly)) {
        testonly = invoker.testonly
      }
      if (defined(invoker.export_define)) {
        defines += [ invoker.export_define ]
      }
      if (defined(invoker.export_define_blink)) {
        defines += [ invoker.export_define_blink ]
      }
      if (enabled_sources != []) {
        sources = process_file_template(enabled_sources, generator_cpp_outputs)
      }
      deps = [
        "//mojo/public/cpp/bindings:struct_traits",
        "//mojo/public/interfaces/bindings:bindings__generator",
        "//mojo/public/interfaces/bindings:bindings_shared__generator",
      ]
      public_deps = [
        ":$shared_cpp_library_target_name",
        "//base",
        "//mojo/public/cpp/bindings",
      ]
      if (enabled_sources != []) {
        public_deps += [ ":$generator_target_name" ]
      }
      if (defined(invoker.component_macro_prefix)) {
        output_name = "${invoker.component_output_prefix}${variant_suffix}"
        defines += [ "${invoker.component_macro_prefix}${bindings_configuration.component_macro_suffix}_IMPL" ]
        sources += [ get_path_info(generated_export_header, "abspath") ]
        deps += [ ":$export_header_generator_target_name" ]
      }
      foreach(d, all_deps) {
        # Resolve the name, so that a target //mojo/something becomes
        # //mojo/something:something and we can append variant_suffix to
        # get the cpp dependency name.
        full_name = get_label_info("$d", "label_no_toolchain")
        public_deps += [ "${full_name}${variant_suffix}" ]
      }
      if (defined(bindings_configuration.for_blink) &&
          bindings_configuration.for_blink) {
        if (defined(invoker.overridden_deps_blink)) {
          foreach(d, invoker.overridden_deps_blink) {
            # Resolve the name, so that a target //mojo/something becomes
            # //mojo/something:something and we can append variant_suffix
            # to get the cpp dependency name.
            full_name = get_label_info("$d", "label_no_toolchain")
            public_deps -= [ "${full_name}${variant_suffix}" ]
          }
          public_deps += invoker.component_deps_blink
        }
      } else {
        if (defined(invoker.overridden_deps)) {
          foreach(d, invoker.overridden_deps) {
            # Resolve the name, so that a target //mojo/something becomes
            # //mojo/something:something and we can append variant_suffix
            # to get the cpp dependency name.
            full_name = get_label_info("$d", "label_no_toolchain")
            public_deps -= [ "${full_name}${variant_suffix}" ]
          }
          public_deps += invoker.component_deps
        }
      }
      foreach(typemap, active_typemaps) {
        _typemap_config = {
        }
        _typemap_config = typemap.config
        if (defined(_typemap_config.public_headers)) {
          sources += _typemap_config.public_headers
        }
        if (defined(_typemap_config.traits_headers)) {
          sources += _typemap_config.traits_headers
        }
        if (defined(_typemap_config.sources)) {
          sources += _typemap_config.sources
        }
        if (defined(_typemap_config.public_deps)) {
          public_deps += _typemap_config.public_deps
        }
        if (defined(_typemap_config.deps)) {
          deps += _typemap_config.deps
        }
      }
      if (defined(invoker.export_header)) {
        sources += [ "//" + invoker.export_header ]
      }
      if (defined(bindings_configuration.for_blink) &&
          bindings_configuration.for_blink) {
        public_deps += [ "//mojo/public/cpp/bindings:wtf_support" ]
      }
    }

    if (!cpp_only && is_android) {
      import("//build/config/android/rules.gni")

      java_srcjar_target_name = target_name + "_java_sources"
      action(java_srcjar_target_name) {
        script = "//mojo/public/tools/gn/zip.py"
        inputs = []
        if (enabled_sources != []) {
          inputs =
              process_file_template(enabled_sources, generator_java_outputs)
        }
        output = "$target_gen_dir/$target_name.srcjar"
        outputs = [
          output,
        ]
        rebase_inputs = rebase_path(inputs, root_build_dir)
        rebase_output = rebase_path(output, root_build_dir)
        args = [
          "--zip-inputs=$rebase_inputs",
          "--output=$rebase_output",
        ]
        deps = []
        if (enabled_sources != []) {
          deps = [
            ":$generator_target_name",
          ]
        }
      }

      java_target_name = target_name + "_java"
      android_library(java_target_name) {
        deps = [
          "//base:base_java",
          "//mojo/public/java:bindings_java",
          "//mojo/public/java:system_java",
        ]

        foreach(d, all_deps) {
          # Resolve the name, so that a target //mojo/something becomes
          # //mojo/something:something and we can append "_java" to get the java
          # dependency name.
          full_name = get_label_info(d, "label_no_toolchain")
          deps += [ "${full_name}_java" ]
        }

        srcjar_deps = [ ":$java_srcjar_target_name" ]
        run_findbugs_override = false
      }
    }
  }

  if (!defined(invoker.cpp_only) || !invoker.cpp_only) {
    if (defined(invoker.sources)) {
      generator_js_target_name = "${target_name}_js__generator"
      generator_js_outputs =
          [ "{{source_gen_dir}}/{{source_name_part}}.mojom.js" ]
      action_foreach(generator_js_target_name) {
        script = mojom_generator_script
        inputs = mojom_generator_sources
        sources = []
        if (defined(invoker.sources)) {
          sources += invoker.sources
        }
        deps = [
          "//mojo/public/tools/bindings:precompile_templates",
        ]
        outputs = generator_js_outputs
        args = common_generator_args
        args += [
          "-g",
          "javascript",
        ]

        args += [
          "--js_bindings_mode",
          js_bindings_mode,
        ]
      }
    }

    js_target_name = target_name + "_js"
    group(js_target_name) {
      public_deps = []
      if (defined(invoker.sources)) {
        public_deps += [ ":$generator_js_target_name" ]
      }

      foreach(d, all_deps) {
        full_name = get_label_info(d, "label_no_toolchain")
        public_deps += [ "${full_name}_js" ]
      }
    }

    js_data_deps_target_name = target_name + "_js_data_deps"
    group(js_data_deps_target_name) {
      deps = []
      if (defined(invoker.sources)) {
        data = process_file_template(invoker.sources, generator_js_outputs)
        deps += [ ":$generator_js_target_name" ]
      }

      data_deps = []
      foreach(d, all_deps) {
        full_name = get_label_info(d, "label_no_toolchain")
        data_deps += [ "${full_name}_js_data_deps" ]
      }
    }
  }
}

# A helper for the mojom() template above when component libraries are desired
# for generated C++ bindings units. Supports all the same arguments as mojom()
# except for the optional |component_output_prefix| and |component_macro_prefix|
# arguments. These are instead shortened to |output_prefix| and |macro_prefix|
# and are *required*.
template("mojom_component") {
  assert(defined(invoker.output_prefix) && defined(invoker.macro_prefix))

  mojom(target_name) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "output_prefix",
                             "macro_prefix",
                           ])
    component_output_prefix = invoker.output_prefix
    component_macro_prefix = invoker.macro_prefix
  }
}