# 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.

# Do not add any imports to non-//build directories here.
# Some projects (e.g. V8) do not have non-build directories DEPS'ed in.
import("//build/config/android/config.gni")
import("//build/config/android/internal_rules.gni")
import("//build/config/clang/clang.gni")
import("//build/config/compiler/compiler.gni")
import("//build/config/compute_inputs_for_analyze.gni")
import("//build/config/dcheck_always_on.gni")
import("//build/toolchain/toolchain.gni")

assert(is_android)

declare_args() {
  enable_jni_tracing = false
}

if (target_cpu == "arm") {
  _sanitizer_arch = "arm"
} else if (target_cpu == "arm64") {
  _sanitizer_arch = "aarch64"
} else if (target_cpu == "x86") {
  _sanitizer_arch = "i686"
}

_sanitizer_runtimes = []
if (use_cfi_diag || is_ubsan || is_ubsan_security || is_ubsan_vptr) {
  _sanitizer_runtimes = [ "$clang_base_path/lib/clang/$clang_version/lib/linux/libclang_rt.ubsan_standalone-$_sanitizer_arch-android.so" ]
}

# Creates a dist directory for a native executable.
#
# Running a native executable on a device requires all the shared library
# dependencies of that executable. To make it easier to install and run such an
# executable, this will create a directory containing the native exe and all
# it's library dependencies.
#
# Note: It's usually better to package things as an APK than as a native
# executable.
#
# Variables
#   dist_dir: Directory for the exe and libraries. Everything in this directory
#     will be deleted before copying in the exe and libraries.
#   binary: Path to (stripped) executable.
#   extra_files: List of extra files to copy in (optional).
#
# Example
#   create_native_executable_dist("foo_dist") {
#     dist_dir = "$root_build_dir/foo_dist"
#     binary = "$root_build_dir/foo"
#     deps = [ ":the_thing_that_makes_foo" ]
#   }
template("create_native_executable_dist") {
  forward_variables_from(invoker, [ "testonly" ])

  _libraries_list = "${target_gen_dir}/${target_name}_library_dependencies.list"

  _runtime_deps_file = "$target_gen_dir/${target_name}.runtimedeps"
  _runtime_deps_target_name = "${target_name}__runtime_deps"
  group(_runtime_deps_target_name) {
    data = _sanitizer_runtimes
    data_deps = []
    if (defined(invoker.deps)) {
      data_deps += invoker.deps
    }
    if (is_component_build || is_asan) {
      data_deps += [ "//build/android:cpplib_stripped" ]
    }
    write_runtime_deps = _runtime_deps_file
  }

  _find_deps_target_name = "${target_name}__find_library_dependencies"

  # TODO(agrieve): Extract dependent libs from GN rather than readelf.
  action(_find_deps_target_name) {
    deps = invoker.deps + [ ":$_runtime_deps_target_name" ]
    script = "//build/android/gyp/write_ordered_libraries.py"
    depfile = "$target_gen_dir/$target_name.d"
    inputs = [
      invoker.binary,
      _runtime_deps_file,
      android_readelf,
    ]
    outputs = [
      _libraries_list,
    ]
    args = [
      "--depfile",
      rebase_path(depfile, root_build_dir),
      "--runtime-deps",
      rebase_path(_runtime_deps_file, root_build_dir),
      "--output",
      rebase_path(_libraries_list, root_build_dir),
      "--readelf",
      rebase_path(android_readelf, root_build_dir),
    ]
  }

  copy_ex(target_name) {
    inputs = [
      _libraries_list,
      invoker.binary,
    ]

    dest = invoker.dist_dir
    data = [
      "${invoker.dist_dir}/",
    ]

    _rebased_libraries_list = rebase_path(_libraries_list, root_build_dir)
    _rebased_binaries_list = rebase_path([ invoker.binary ], root_build_dir)
    args = [
      "--clear",
      "--files=@FileArg($_rebased_libraries_list:lib_paths)",
      "--files=$_rebased_binaries_list",
    ]
    if (defined(invoker.extra_files)) {
      _rebased_extra_files = rebase_path(invoker.extra_files, root_build_dir)
      args += [ "--files=$_rebased_extra_files" ]
    }

    _depfile = "$target_gen_dir/$target_name.d"
    _stamp_file = "$target_gen_dir/$target_name.stamp"
    outputs = [
      _stamp_file,
    ]
    args += [
      "--depfile",
      rebase_path(_depfile, root_build_dir),
      "--stamp",
      rebase_path(_stamp_file, root_build_dir),
    ]

    deps = [
      ":$_find_deps_target_name",
    ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
  }
}

# Writes a script to root_out_dir/bin that passes --output-directory to the
# wrapped script, in addition to forwarding arguments. Most / all of these
# wrappers should be made deps of //tools/android:android_tools.
#
# Variables
#   target: Script to wrap.
#   flag_name: Default is "--output-directory"
#
# Example
#   wrapper_script("foo_wrapper") {
#     target = "//pkg/foo.py"
#   }
template("wrapper_script") {
  action(target_name) {
    _name = get_path_info(invoker.target, "name")
    _output = "$root_out_dir/bin/$_name"

    script = "//build/android/gyp/create_tool_wrapper.py"
    outputs = [
      _output,
    ]

    # The target isn't actually used by the script, but it's nice to have GN
    # check that it exists.
    inputs = [
      invoker.target,
    ]
    args = [
      "--output",
      rebase_path(_output, root_build_dir),
      "--target",
      rebase_path(invoker.target, root_build_dir),
      "--output-directory",
      rebase_path(root_out_dir, root_build_dir),
    ]
    if (defined(invoker.flag_name)) {
      args += [ "--flag-name=${invoker.flag_name}" ]
    }
  }
}

if (enable_java_templates) {
  import("//build/config/sanitizers/sanitizers.gni")
  import("//tools/grit/grit_rule.gni")

  # Declare a jni target
  #
  # This target generates the native jni bindings for a set of .java files.
  #
  # See base/android/jni_generator/jni_generator.py for more info about the
  # format of generating JNI bindings.
  #
  # Variables
  #   sources: list of .java files to generate jni for
  #   jni_package: subdirectory path for generated bindings
  #
  # Example
  #   generate_jni("foo_jni") {
  #     sources = [
  #       "android/java/src/org/chromium/foo/Foo.java",
  #       "android/java/src/org/chromium/foo/FooUtil.java",
  #     ]
  #     jni_package = "foo"
  #   }
  template("generate_jni") {
    set_sources_assignment_filter([])
    forward_variables_from(invoker, [ "testonly" ])

    _base_output_dir = "${target_gen_dir}/${target_name}"
    _package_output_dir = "${_base_output_dir}/${invoker.jni_package}"
    _jni_output_dir = "${_package_output_dir}/jni"

    if (defined(invoker.jni_generator_include)) {
      _jni_generator_include = invoker.jni_generator_include
      _jni_generator_include_deps = []
    } else {
      _jni_generator_include =
          "//base/android/jni_generator/jni_generator_helper.h"
      _jni_generator_include_deps = [
        # Using //base/android/jni_generator/jni_generator_helper.h introduces
        # a dependency on debugging_buildflags indirectly through
        # base/android/jni_android.h, which is part of the //base target.
        # This can't depend directly on //base without causing a dependency
        # cycle, though.
        "//base:debugging_buildflags",
      ]
    }

    _foreach_target_name = "${target_name}__jni_gen"
    action_foreach(_foreach_target_name) {
      script = "//base/android/jni_generator/jni_generator.py"
      depfile = "$target_gen_dir/$target_name.{{source_name_part}}.d"
      sources = invoker.sources
      outputs = [
        "${_jni_output_dir}/{{source_name_part}}_jni.h",
      ]

      args = [
        "--depfile",
        rebase_path(depfile, root_build_dir),
        "--input_file={{source}}",
        "--ptr_type=long",
        "--output_dir",
        rebase_path(_jni_output_dir, root_build_dir),
        "--includes",
        rebase_path(_jni_generator_include, _jni_output_dir),
      ]

      if (enable_profiling) {
        args += [ "--enable_profiling" ]
      }
      if (defined(invoker.namespace)) {
        args += [ "-n ${invoker.namespace}" ]
      }
      if (enable_jni_tracing) {
        args += [ "--enable_tracing" ]
      }
    }

    config("jni_includes_${target_name}") {
      # TODO(cjhopman): #includes should probably all be relative to
      # _base_output_dir. Remove that from this config once the includes are
      # updated.
      include_dirs = [
        _base_output_dir,
        _package_output_dir,
      ]
    }

    group(target_name) {
      forward_variables_from(invoker,
                             [
                               "deps",
                               "public_deps",
                               "visibility",
                             ])
      if (!defined(public_deps)) {
        public_deps = []
      }
      public_deps += [ ":$_foreach_target_name" ]
      public_deps += _jni_generator_include_deps
      public_configs = [ ":jni_includes_${target_name}" ]
    }
  }

  # Declare a jni target for a prebuilt jar
  #
  # This target generates the native jni bindings for a set of classes in a .jar.
  #
  # See base/android/jni_generator/jni_generator.py for more info about the
  # format of generating JNI bindings.
  #
  # Variables
  #   classes: list of .class files in the jar to generate jni for. These should
  #     include the full path to the .class file.
  #   jni_package: subdirectory path for generated bindings
  #   jar_file: the path to the .jar. If not provided, will default to the sdk's
  #     android.jar
  #
  #   deps, public_deps: As normal
  #
  # Example
  #   generate_jar_jni("foo_jni") {
  #     classes = [
  #       "android/view/Foo.class",
  #     ]
  #     jni_package = "foo"
  #   }
  template("generate_jar_jni") {
    forward_variables_from(invoker, [ "testonly" ])

    if (defined(invoker.jar_file)) {
      _jar_file = invoker.jar_file
    } else {
      _jar_file = android_sdk_jar
    }

    _base_output_dir = "${target_gen_dir}/${target_name}/${invoker.jni_package}"
    _jni_output_dir = "${_base_output_dir}/jni"

    if (defined(invoker.jni_generator_include)) {
      _jni_generator_include = invoker.jni_generator_include
    } else {
      _jni_generator_include =
          "//base/android/jni_generator/jni_generator_helper.h"
    }

    # TODO(cjhopman): make jni_generator.py support generating jni for multiple
    # .class files from a .jar.
    _jni_actions = []
    foreach(_class, invoker.classes) {
      _classname = get_path_info(_class, "name")
      _jni_target_name = "${target_name}__jni_${_classname}"
      _jni_actions += [ ":$_jni_target_name" ]
      action(_jni_target_name) {
        # The sources aren't compiled so don't check their dependencies.
        check_includes = false
        depfile = "$target_gen_dir/$target_name.d"
        script = "//base/android/jni_generator/jni_generator.py"
        inputs = [
          _jar_file,
        ]
        outputs = [
          "${_jni_output_dir}/${_classname}_jni.h",
        ]

        args = [
          "--depfile",
          rebase_path(depfile, root_build_dir),
          "--jar_file",
          rebase_path(_jar_file, root_build_dir),
          "--input_file",
          _class,
          "--ptr_type=long",
          "--output_dir",
          rebase_path(_jni_output_dir, root_build_dir),
          "--includes",
          rebase_path(_jni_generator_include, _jni_output_dir),
        ]

        if (enable_profiling) {
          args += [ "--enable_profiling" ]
        }
        if (enable_jni_tracing) {
          args += [ "--enable_tracing" ]
        }
      }
    }

    config("jni_includes_${target_name}") {
      include_dirs = [ _base_output_dir ]
    }

    group(target_name) {
      public_deps = []
      forward_variables_from(invoker,
                             [
                               "deps",
                               "public_deps",
                               "visibility",
                             ])
      public_deps += _jni_actions
      public_configs = [ ":jni_includes_${target_name}" ]
    }
  }

  # Declare a jni registration target.
  #
  # This target generates a header file calling JNI registration functions
  # created by generate_jni and generate_jar_jni.
  #
  # See base/android/jni_generator/jni_registration_generator.py for more info
  # about the format of the header file.
  #
  # Variables
  #   target: The Apk target to generate registrations for.
  #   output: Path to the generated .h file.
  #   exception_files: List of .java files that should be ignored when searching
  #   for native methods. (optional)
  #
  # Example
  #   generate_jni_registration("chrome_jni_registration") {
  #     target = ":chrome_public_apk"
  #     output = "$root_gen_dir/chrome/browser/android/${target_name}.h"
  #     exception_files = [
  #       "//base/android/java/src/org/chromium/base/library_loader/Linker.java",
  #     ]
  #   }
  template("generate_jni_registration") {
    action(target_name) {
      forward_variables_from(invoker, [ "testonly" ])
      _build_config = get_label_info(invoker.target, "target_gen_dir") + "/" +
                      get_label_info(invoker.target, "name") + ".build_config"
      _rebased_build_config = rebase_path(_build_config, root_build_dir)

      _rebase_exception_java_files =
          rebase_path(invoker.exception_files, root_build_dir)

      script = "//base/android/jni_generator/jni_registration_generator.py"
      deps = [
        "${invoker.target}__build_config",
      ]
      inputs = [
        _build_config,
      ]
      outputs = [
        invoker.output,
      ]
      depfile = "$target_gen_dir/$target_name.d"

      args = [
        # This is a list of .sources files.
        "--sources_files=@FileArg($_rebased_build_config:jni:all_source)",
        "--output",
        rebase_path(invoker.output, root_build_dir),
        "--no_register_java=$_rebase_exception_java_files",
        "--depfile",
        rebase_path(depfile, root_build_dir),
      ]
    }
  }

  # Declare a target for c-preprocessor-generated java files
  #
  # NOTE: For generating Java conterparts to enums prefer using the java_cpp_enum
  #       rule instead.
  #
  # This target generates java files using the host C pre-processor. Each file in
  # sources will be compiled using the C pre-processor. If include_path is
  # specified, it will be passed (with --I) to the pre-processor.
  #
  # This target will create a single .srcjar. Adding this target to an
  # android_library target's srcjar_deps will make the generated java files be
  # included in that library's final outputs.
  #
  # Variables
  #   sources: list of files to be processed by the C pre-processor. For each
  #     file in sources, there will be one .java file in the final .srcjar. For a
  #     file named FooBar.template, a java file will be created with name
  #     FooBar.java.
  #   inputs: additional compile-time dependencies. Any files
  #     `#include`-ed in the templates should be listed here.
  #   package_path: this will be the subdirectory for each .java file in the
  #     .srcjar.
  #
  # Example
  #   java_cpp_template("foo_generated_enum") {
  #     sources = [
  #       "android/java/templates/Foo.template",
  #     ]
  #     inputs = [
  #       "android/java/templates/native_foo_header.h",
  #     ]
  #
  #     package_path = "org/chromium/base/library_loader"
  #     include_path = "android/java/templates"
  #   }
  template("java_cpp_template") {
    set_sources_assignment_filter([])
    forward_variables_from(invoker, [ "testonly" ])

    _include_path = "//"
    if (defined(invoker.include_path)) {
      _include_path = invoker.include_path
    }

    _apply_gcc_target_name = "${target_name}__apply_gcc"
    _base_gen_dir = "${target_gen_dir}/${target_name}/java_cpp_template"
    _package_path = invoker.package_path

    action_foreach(_apply_gcc_target_name) {
      forward_variables_from(invoker,
                             [
                               "deps",
                               "inputs",
                               "public_deps",
                               "data_deps",
                             ])
      script = "//build/android/gyp/gcc_preprocess.py"
      depfile =
          "${target_gen_dir}/${invoker.target_name}_{{source_name_part}}.d"

      sources = invoker.sources

      outputs = [
        "$_base_gen_dir/${_package_path}/{{source_name_part}}.java",
      ]

      args = [
        "--depfile",
        rebase_path(depfile, root_build_dir),
        "--include-path",
        rebase_path(_include_path, root_build_dir),
        "--output",
        rebase_path(outputs[0], root_build_dir),
        "--template={{source}}",
      ]

      if (defined(invoker.defines)) {
        foreach(_def, invoker.defines) {
          args += [
            "--defines",
            _def,
          ]
        }
      }
    }

    # Filter out .d files.
    set_sources_assignment_filter([ "*.d" ])
    sources = get_target_outputs(":$_apply_gcc_target_name")

    zip(target_name) {
      forward_variables_from(invoker, [ "visibility" ])
      inputs = sources
      output = "${target_gen_dir}/${target_name}.srcjar"
      base_dir = _base_gen_dir
      deps = [
        ":$_apply_gcc_target_name",
      ]
    }
  }

  # Declare a target for generating Java classes from C++ enums.
  #
  # This target generates Java files from C++ enums using a script.
  #
  # This target will create a single .srcjar. Adding this target to an
  # android_library target's srcjar_deps will make the generated java files be
  # included in that library's final outputs.
  #
  # Variables
  #   sources: list of files to be processed by the script. For each annotated
  #     enum contained in the sources files the script will generate a .java
  #     file with the same name as the name of the enum.
  #
  # Example
  #   java_cpp_enum("foo_generated_enum") {
  #     sources = [
  #       "src/native_foo_header.h",
  #     ]
  #   }
  template("java_cpp_enum") {
    set_sources_assignment_filter([])
    action(target_name) {
      forward_variables_from(invoker,
                             [
                               "sources",
                               "testonly",
                               "visibility",
                             ])

      # The sources aren't compiled so don't check their dependencies.
      check_includes = false
      script = "//build/android/gyp/java_cpp_enum.py"
      depfile = "$target_gen_dir/$target_name.d"

      _srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
      _rebased_srcjar_path = rebase_path(_srcjar_path, root_build_dir)
      _rebased_sources = rebase_path(invoker.sources, root_build_dir)

      args = [
               "--depfile",
               rebase_path(depfile, root_build_dir),
               "--srcjar=$_rebased_srcjar_path",
             ] + _rebased_sources
      outputs = [
        _srcjar_path,
      ]
    }
  }

  if (compute_inputs_for_analyze) {
    _jinja_template_pydeps =
        exec_script("//build/print_python_deps.py",
                    [
                      rebase_path("//build/android/gyp/jinja_template.py"),
                      "--no-header",
                      "--gn-paths",
                      "--root",
                      rebase_path("//", root_build_dir),
                    ],
                    "list lines")
  }

  # Declare a target for processing a Jinja template.
  #
  # Variables
  #   input: The template file to be processed.
  #   includes: List of files {% include %}'ed by input.
  #   output: Where to save the result.
  #   variables: (Optional) A list of variables to make available to the template
  #     processing environment, e.g. ["name=foo", "color=red"].
  #
  # Example
  #   jinja_template("chrome_public_manifest") {
  #     input = "java/AndroidManifest.xml"
  #     output = "$target_gen_dir/AndroidManifest.xml"
  #   }
  template("jinja_template") {
    forward_variables_from(invoker, [ "testonly" ])

    action(target_name) {
      forward_variables_from(invoker,
                             [
                               "visibility",
                               "deps",
                             ])

      inputs = [
        invoker.input,
      ]
      if (defined(invoker.includes)) {
        inputs += invoker.includes
      }
      if (compute_inputs_for_analyze) {
        inputs += _jinja_template_pydeps
      }
      script = "//build/android/gyp/jinja_template.py"
      depfile = "$target_gen_dir/$target_name.d"

      outputs = [
        invoker.output,
      ]

      args = [
        "--loader-base-dir",
        rebase_path("//", root_build_dir),
        "--inputs",
        rebase_path(invoker.input, root_build_dir),
        "--output",
        rebase_path(invoker.output, root_build_dir),
        "--depfile",
        rebase_path(depfile, root_build_dir),
      ]
      if (defined(invoker.includes)) {
        _rebased_includes = rebase_path(invoker.includes, root_build_dir)
        args += [ "--includes=$_rebased_includes" ]
      }
      if (defined(invoker.variables)) {
        args += [ "--variables=${invoker.variables}" ]
      }
    }
  }

  # Declare a target for a set of Android resources generated at build
  # time and stored in a single zip archive. The content of the archive
  # should match the layout of a regular Android res/ folder (but the
  # archive should not include a top-level res/ directory).
  #
  # Note that there is no associated .srcjar, R.txt or package name
  # associated with this target.
  #
  # Variables:
  #   generated_resources_zip: Generated zip archive path.
  #   generating_target_name: Name of the target generating
  #     generated_resources_zip. This rule will check that it is part
  #     of its outputs.
  #   deps: Specifies the dependencies of this target. Any Android resources
  #     listed here will be also be included *after* this one when compiling
  #     all resources for a final apk or junit binary. This is useful to
  #     ensure that the resources of the current target override those of the
  #     dependency as well (and would not work if you have these deps to the
  #     generating target's dependencies).
  #
  # Example
  #   _zip_archive = "$target_gen_dir/${target_name}.resources_zip"
  #
  #   action("my_resources__create_zip") {
  #     _depfile = "$target_gen_dir/${target_name}.d"
  #     script = "//build/path/to/create_my_resources_zip.py"
  #     args = [
  #       "--depfile", rebase_path(_depfile, root_build_dir),
  #       "--output-zip", rebase_path(_zip_archive, root_build_dir),
  #     ]
  #     inputs = []
  #     outputs = _zip_archive
  #     depfile = _depfile
  #   }
  #
  #   android_generated_resources("my_resources") {
  #      generated_resources_zip = _zip_archive
  #      generating_target_name = ":my_resources__create_zip"
  #   }
  #
  template("android_generated_resources") {
    forward_variables_from(invoker, [ "testonly" ])

    _build_config = "$target_gen_dir/${target_name}.build_config"

    write_build_config("${target_name}__build_config") {
      build_config = _build_config
      resources_zip = invoker.generated_resources_zip
      type = "android_resources"
      if (defined(invoker.deps)) {
        possible_config_deps = invoker.deps
      }
    }

    group(target_name) {
      public_deps = [
        ":${target_name}__build_config",
        invoker.generating_target_name,
      ]
    }
  }

  # Declare a target for processing Android resources as Jinja templates.
  #
  # This takes an Android resource directory where each resource is a Jinja
  # template, processes each template, then packages the results in a zip file
  # which can be consumed by an android resources, library, or apk target.
  #
  # If this target is included in the deps of an android resources/library/apk,
  # the resources will be included with that target.
  #
  # Variables
  #   resources: The list of resources files to process.
  #   res_dir: The resource directory containing the resources.
  #   variables: (Optional) A list of variables to make available to the template
  #     processing environment, e.g. ["name=foo", "color=red"].
  #
  # Example
  #   jinja_template_resources("chrome_public_template_resources") {
  #     res_dir = "res_template"
  #     resources = ["res_template/xml/syncable.xml"]
  #     variables = ["color=red"]
  #   }
  template("jinja_template_resources") {
    forward_variables_from(invoker, [ "testonly" ])

    # JUnit tests use resource zip files. These must not be put in gen/
    # directory or they will not be available to tester bots.
    _resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
    _resources_zip = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"

    _generating_target_name = "${target_name}__template"

    action(_generating_target_name) {
      forward_variables_from(invoker, [ "deps" ])
      inputs = invoker.resources
      script = "//build/android/gyp/jinja_template.py"
      depfile = "$target_gen_dir/$target_name.d"

      outputs = [
        _resources_zip,
      ]

      _rebased_resources = rebase_path(invoker.resources, root_build_dir)
      args = [
        "--inputs=${_rebased_resources}",
        "--inputs-base-dir",
        rebase_path(invoker.res_dir, root_build_dir),
        "--outputs-zip",
        rebase_path(_resources_zip, root_build_dir),
        "--depfile",
        rebase_path(depfile, root_build_dir),
      ]
      if (defined(invoker.variables)) {
        variables = invoker.variables
        args += [ "--variables=${variables}" ]
      }
    }

    android_generated_resources(target_name) {
      forward_variables_from(invoker, [ "deps" ])
      generating_target_name = ":$_generating_target_name"
      generated_resources_zip = _resources_zip
    }
  }

  # Declare an Android resources target
  #
  # This creates a resources zip file that will be used when building an Android
  # library or apk and included into a final apk.
  #
  # To include these resources in a library/apk, this target should be listed in
  # the library's deps. A library/apk will also include any resources used by its
  # own dependencies.
  #
  # Variables
  #   deps: Specifies the dependencies of this target. Any Android resources
  #     listed in deps will be included by libraries/apks that depend on this
  #     target.
  #   alternative_android_sdk_dep: Optional. Alternative Android system
  #     android java target to use.
  #   resource_dirs: List of directories containing resources for this target.
  #   generated_resource_dirs: List of directories containing resources for this
  #     target which are *generated* by a dependency. |generated_resource_files|
  #     must be specified if |generated_resource_dirs| is specified.
  #   generated_resource_files: List of all files in |generated_resource_dirs|.
  #     |generated_resource_dirs| must be specified in |generated_resource_files|
  #     is specified.
  #   android_manifest: AndroidManifest.xml for this target (optional). Will be
  #     merged into apks that directly or indirectly depend on this target.
  #   android_manifest_dep: Target that generates AndroidManifest (if applicable)
  #   custom_package: java package for generated .java files.
  #   v14_skip: If true, don't run v14 resource generator on this. Defaults to
  #     false. (see build/android/gyp/generate_v14_compatible_resources.py)
  #   shared_resources: If true make a resource package that can be loaded by a
  #     different application at runtime to access the package's resources.
  #   r_text_file: (optional) path to pre-generated R.txt to be used when
  #     generating R.java instead of resource-based aapt-generated one.
  #   create_srcjar: If false, does not create an R.java file. Needed only for
  #     prebuilts that have R.txt files that do not match their res/
  #     (Play Services).
  #
  # Example:
  #   android_resources("foo_resources") {
  #     deps = [":foo_strings_grd"]
  #     resource_dirs = ["res"]
  #     custom_package = "org.chromium.foo"
  #   }
  #
  #   android_resources("foo_resources_overrides") {
  #     deps = [":foo_resources"]
  #     resource_dirs = ["res_overrides"]
  #   }
  template("android_resources") {
    forward_variables_from(invoker, [ "testonly" ])

    _base_path = "$target_gen_dir/$target_name"

    # JUnit tests use resource zip files. These must not be put in gen/
    # directory or they will not be available to tester bots.
    _resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
    _zip_path = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"
    _r_text_out_path = _base_path + "_R.txt"
    _build_config = _base_path + ".build_config"
    _build_config_target_name = "${target_name}__build_config"

    if (!defined(invoker.create_srcjar) || invoker.create_srcjar) {
      _srcjar_path = _base_path + ".srcjar"
    }

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

    if (defined(invoker.alternative_android_sdk_dep)) {
      _deps += [ invoker.alternative_android_sdk_dep ]
    } else {
      _deps += [ "//third_party/android_tools:android_sdk_java" ]
    }

    write_build_config(_build_config_target_name) {
      type = "android_resources"
      build_config = _build_config
      resources_zip = _zip_path

      resource_dirs = invoker.resource_dirs
      if (defined(invoker.generated_resource_dirs)) {
        resource_dirs += invoker.generated_resource_dirs
      }

      if (defined(_srcjar_path)) {
        forward_variables_from(invoker,
                               [
                                 "android_manifest",
                                 "android_manifest_dep",
                                 "custom_package",
                               ])

        # No package means resources override their deps.
        if (defined(custom_package) || defined(android_manifest)) {
          r_text = _r_text_out_path
        } else {
          assert(defined(invoker.deps),
                 "Must specify deps when custom_package is omitted.")
        }
        srcjar = _srcjar_path
      }

      possible_config_deps = _deps
    }

    prepare_resources(target_name) {
      forward_variables_from(invoker,
                             [
                               "android_manifest",
                               "custom_package",
                               "generated_resource_dirs",
                               "generated_resource_files",
                               "resource_dirs",
                               "v14_skip",
                             ])
      deps = _deps
      deps += [ ":$_build_config_target_name" ]
      if (defined(invoker.android_manifest_dep)) {
        deps += [ invoker.android_manifest_dep ]
      }

      build_config = _build_config
      zip_path = _zip_path
      r_text_out_path = _r_text_out_path

      if (defined(invoker.r_text_file)) {
        r_text_in_path = invoker.r_text_file
      }
      if (defined(_srcjar_path)) {
        srcjar_path = _srcjar_path
      }

      # Always generate R.onResourcesLoaded() method, it is required for
      # compiling ResourceRewriter, there is no side effect because the
      # generated R.class isn't used in final apk.
      shared_resources = true
    }
  }

  # Declare an Android assets target.
  #
  # Defines a set of files to include as assets in a dependent apk.
  #
  # To include these assets in an apk, this target should be listed in
  # the apk's deps, or in the deps of a library target used by an apk.
  #
  # Variables
  #   deps: Specifies the dependencies of this target. Any Android assets
  #     listed in deps will be included by libraries/apks that depend on this
  #     target.
  #   sources: List of files to include as assets.
  #   renaming_sources: List of files to include as assets and be renamed.
  #   renaming_destinations: List of asset paths for files in renaming_sources.
  #   disable_compression: Whether to disable compression for files that are
  #     known to be compressable (default: false).
  #   treat_as_locale_paks: Causes base's BuildConfig.java to consider these
  #     assets to be locale paks.
  #
  # Example:
  # android_assets("content_shell_assets") {
  #   deps = [
  #     ":generates_foo",
  #     ":other_assets",
  #     ]
  #   sources = [
  #     "//path/asset1.png",
  #     "//path/asset2.png",
  #     "$target_gen_dir/foo.dat",
  #   ]
  # }
  #
  # android_assets("overriding_content_shell_assets") {
  #   deps = [ ":content_shell_assets" ]
  #   # Override foo.dat from content_shell_assets.
  #   sources = [ "//custom/foo.dat" ]
  #   renaming_sources = [ "//path/asset2.png" ]
  #   renaming_destinations = [ "renamed/asset2.png" ]
  # }
  template("android_assets") {
    forward_variables_from(invoker, [ "testonly" ])

    _build_config = "$target_gen_dir/$target_name.build_config"
    _build_config_target_name = "${target_name}__build_config"

    write_build_config(_build_config_target_name) {
      type = "android_assets"
      build_config = _build_config

      forward_variables_from(invoker,
                             [
                               "disable_compression",
                               "treat_as_locale_paks",
                             ])

      if (defined(invoker.deps)) {
        possible_config_deps = invoker.deps
      }

      if (defined(invoker.sources)) {
        asset_sources = invoker.sources
      }
      if (defined(invoker.renaming_sources)) {
        assert(defined(invoker.renaming_destinations))
        _source_count = 0
        foreach(_, invoker.renaming_sources) {
          _source_count += 1
        }
        _dest_count = 0
        foreach(_, invoker.renaming_destinations) {
          _dest_count += 1
        }
        assert(
            _source_count == _dest_count,
            "android_assets() renaming_sources.length != renaming_destinations.length")
        asset_renaming_sources = invoker.renaming_sources
        asset_renaming_destinations = invoker.renaming_destinations
      }
    }

    group(target_name) {
      forward_variables_from(invoker,
                             [
                               "deps",
                               "visibility",
                             ])
      public_deps = [
        ":$_build_config_target_name",
      ]
    }
  }

  # Declare a group() that supports forwarding java dependency information.
  #
  # Example
  #  java_group("conditional_deps") {
  #    if (enable_foo) {
  #      deps = [":foo_java"]
  #    }
  #  }
  template("java_group") {
    forward_variables_from(invoker, [ "testonly" ])
    write_build_config("${target_name}__build_config") {
      type = "group"
      build_config = "$target_gen_dir/${invoker.target_name}.build_config"
      supports_android = true
      if (defined(invoker.deps)) {
        possible_config_deps = invoker.deps
      }
    }
    group(target_name) {
      forward_variables_from(invoker, "*")
      if (!defined(deps)) {
        deps = []
      }
      deps += [ ":${target_name}__build_config" ]
    }
  }

  # Declare a target that generates localized strings.xml from a .grd file.
  #
  # If this target is included in the deps of an android resources/library/apk,
  # the strings.xml will be included with that target.
  #
  # Variables
  #   deps: Specifies the dependencies of this target.
  #   grd_file: Path to the .grd file to generate strings.xml from.
  #   outputs: Expected grit outputs (see grit rule).
  #
  # Example
  #  java_strings_grd("foo_strings_grd") {
  #    grd_file = "foo_strings.grd"
  #  }
  template("java_strings_grd") {
    forward_variables_from(invoker, [ "testonly" ])

    # JUnit tests use resource zip files. These must not be put in gen/
    # directory or they will not be available to tester bots.
    _resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
    _resources_zip = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"

    _grit_target_name = "${target_name}__grit"
    _grit_output_dir = "$target_gen_dir/${target_name}_grit_output"

    grit(_grit_target_name) {
      forward_variables_from(invoker,
                             [
                               "deps",
                               "defines",
                             ])
      grit_flags = [
        "-E",
        "ANDROID_JAVA_TAGGED_ONLY=false",
      ]
      output_dir = _grit_output_dir
      resource_ids = ""
      source = invoker.grd_file
      outputs = invoker.outputs
    }

    _zip_target_name = "${target_name}__zip"

    zip(_zip_target_name) {
      base_dir = _grit_output_dir

      # This needs to get outputs from grit's internal target, not the final
      # source_set.
      inputs = get_target_outputs(":${_grit_target_name}_grit")
      output = _resources_zip
      deps = [
        ":$_grit_target_name",
      ]
    }

    android_generated_resources(target_name) {
      generating_target_name = ":$_zip_target_name"
      generated_resources_zip = _resources_zip
    }
  }

  # Declare a target that packages strings.xml generated from a grd file.
  #
  # If this target is included in the deps of an android resources/library/apk,
  # the strings.xml will be included with that target.
  #
  # Variables
  #  grit_output_dir: directory containing grit-generated files.
  #  generated_files: list of android resource files to package.
  #
  # Example
  #  java_strings_grd_prebuilt("foo_strings_grd") {
  #    grit_output_dir = "$root_gen_dir/foo/grit"
  #    generated_files = [
  #      "values/strings.xml"
  #    ]
  #  }
  template("java_strings_grd_prebuilt") {
    forward_variables_from(invoker, [ "testonly" ])

    # JUnit tests use resource zip files. These must not be put in gen/
    # directory or they will not be available to tester bots.
    _resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
    _resources_zip = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"

    _zip_target_name = "${target_name}__zip"

    zip(_zip_target_name) {
      forward_variables_from(invoker, [ "visibility" ])

      base_dir = invoker.grit_output_dir
      inputs = rebase_path(invoker.generated_files, ".", base_dir)
      output = _resources_zip
      if (defined(invoker.deps)) {
        deps = invoker.deps
      }
    }

    android_generated_resources(target_name) {
      generating_target_name = ":$_zip_target_name"
      generated_resources_zip = _resources_zip
    }
  }

  # Declare a Java executable target
  #
  # Same as java_library, but also creates a wrapper script within
  # $root_out_dir/bin.
  #
  # Supports all variables of java_library(), plus:
  #   main_class: When specified, a wrapper script is created within
  #     $root_build_dir/bin to launch the binary with the given class as the
  #     entrypoint.
  #   wrapper_script_name: Filename for the wrapper script (default=target_name)
  #   wrapper_script_args: List of additional arguments for the wrapper script.
  #
  # Example
  #   java_binary("foo") {
  #     java_files = [ "org/chromium/foo/FooMain.java" ]
  #     deps = [ ":bar_java" ]
  #     main_class = "org.chromium.foo.FooMain"
  #   }
  #
  #   java_binary("foo") {
  #     jar_path = "lib/prebuilt.jar"
  #     deps = [ ":bar_java" ]
  #     main_class = "org.chromium.foo.FooMain"
  #   }
  template("java_binary") {
    java_library_impl(target_name) {
      forward_variables_from(invoker, "*")
      type = "java_binary"
    }
  }

  # Declare a Java Annotation Processor.
  #
  # Supports all variables of java_library(), plus:
  #   jar_path: Path to a prebuilt jar. Mutually exclusive with java_files &
  #     srcjar_deps.
  #   main_class: The fully-quallified class name of the processor's entry
  #       point.
  #
  # Example
  #   java_annotation_processor("foo_processor") {
  #     java_files = [ "org/chromium/foo/FooProcessor.java" ]
  #     deps = [ ":bar_java" ]
  #     main_class = "org.chromium.foo.FooProcessor"
  #   }
  #
  #   java_annotation_processor("foo_processor") {
  #     jar_path = "lib/prebuilt.jar"
  #     main_class = "org.chromium.foo.FooMain"
  #   }
  #
  #   java_library("...") {
  #     annotation_processor_deps = [":foo_processor"]
  #   }
  #
  template("java_annotation_processor") {
    java_library_impl(target_name) {
      forward_variables_from(invoker, "*")
      type = "java_annotation_processor"
    }
  }

  # Declare a Junit executable target
  #
  # This target creates an executable from java code for running as a junit test
  # suite. The executable will be in the output folder's /bin/ directory.
  #
  # Supports all variables of java_binary().
  #
  # Example
  #   junit_binary("foo") {
  #     java_files = [ "org/chromium/foo/FooTest.java" ]
  #     deps = [ ":bar_java" ]
  #   }
  template("junit_binary") {
    testonly = true

    _java_binary_target_name = "${target_name}__java_binary"
    _test_runner_target_name = "${target_name}__test_runner_script"
    _main_class = "org.chromium.testing.local.JunitTestMain"

    _build_config = "$target_gen_dir/$target_name.build_config"
    _build_config_target_name = "${target_name}__build_config"
    _deps = [
      "//testing/android/junit:junit_test_support",
      "//third_party/junit",
      "//third_party/mockito:mockito_java",
      "//third_party/robolectric:robolectric_all_java",

      # This dep is required if any deps require android (but it doesn't hurt
      # to add it regardless) and is used by bytecode rewritten classes.
      "//build/android/buildhooks:build_hooks_android_impl_java",
    ]
    if (defined(invoker.deps)) {
      _deps += invoker.deps
    }

    _prepare_resources_target = "${target_name}__prepare_resources"
    prepare_resources(_prepare_resources_target) {
      deps = _deps + [ ":$_build_config_target_name" ]
      build_config = _build_config
      srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
      if (defined(invoker.package_name)) {
        custom_package = invoker.package_name
      }
      if (defined(invoker.android_manifest_path)) {
        android_manifest = invoker.android_manifest_path
      } else {
        android_manifest = "//build/android/AndroidManifest.xml"
      }
    }

    java_library_impl(_java_binary_target_name) {
      forward_variables_from(invoker, "*", [ "deps" ])
      type = "junit_binary"
      main_target_name = invoker.target_name

      # Include the android SDK jar(s) for resource processing.
      include_android_sdk = true

      # Robolectric can handle deps that set !supports_android as well those
      # that set requires_android.
      bypass_platform_checks = true
      deps = _deps
      testonly = true
      main_class = _main_class
      wrapper_script_name = "helper/$main_target_name"
      if (!defined(srcjar_deps)) {
        srcjar_deps = []
      }
      srcjar_deps += [
        ":$_prepare_resources_target",

        # This dep is required for any targets that depend on //base:base_java.
        "//base:base_build_config_gen",
      ]
    }

    test_runner_script(_test_runner_target_name) {
      test_name = invoker.target_name
      test_suite = invoker.target_name
      test_type = "junit"
      ignore_all_data_deps = true
      forward_variables_from(invoker,
                             [
                               "android_manifest_path",
                               "package_name",
                             ])
    }

    group(target_name) {
      public_deps = [
        ":$_build_config_target_name",
        ":$_java_binary_target_name",
        ":$_test_runner_target_name",
      ]
    }
  }

  # Declare a java library target
  #
  # Variables
  #   deps: Specifies the dependencies of this target. Java targets in this list
  #     will be added to the javac classpath.
  #   annotation_processor_deps: List of java_annotation_processor targets to
  #     use when compiling.
  #
  #   jar_path: Path to a prebuilt jar. Mutually exclusive with java_files &
  #     srcjar_deps.
  #   java_files: List of .java files included in this library.
  #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
  #     will be added to java_files and be included in this library.
  #
  #   input_jars_paths: A list of paths to the jars that should be included
  #     in the compile-time classpath. These are in addition to library .jars
  #     that appear in deps.
  #   classpath_deps: Deps that should added to the classpath for this target,
  #     but not linked into the apk (use this for annotation processors).
  #
  #   chromium_code: If true, extra analysis warning/errors will be enabled.
  #   enable_errorprone: If true, enables the errorprone compiler.
  #   enable_incremental_javac_override: Overrides the global
  #     enable_incremental_javac.
  #
  #   jar_excluded_patterns: List of patterns of .class files to exclude.
  #   jar_included_patterns: List of patterns of .class files to include.
  #     When omitted, all classes not matched by jar_excluded_patterns are
  #     included. When specified, all non-matching .class files are stripped.
  #
  #   output_name: File name for the output .jar (not including extension).
  #     Defaults to the input .jar file name.
  #
  #   proguard_configs: List of proguard configs to use in final apk step for
  #     any apk that depends on this library.
  #
  #   supports_android: If true, Android targets (android_library, android_apk)
  #     may depend on this target. Note: if true, this target must only use the
  #     subset of Java available on Android.
  #   bypass_platform_checks: Disables checks about cross-platform (Java/Android)
  #     dependencies for this target. This will allow depending on an
  #     android_library target, for example.
  #
  #   additional_jar_files: Use to package additional files (Java resources)
  #     into the output jar. Pass a list of length-2 lists with format:
  #         [ [ path_to_file, path_to_put_in_jar ] ]
  #
  #   javac_args: Additional arguments to pass to javac.
  #
  #   data_deps, testonly
  #
  # Example
  #   java_library("foo_java") {
  #     java_files = [
  #       "org/chromium/foo/Foo.java",
  #       "org/chromium/foo/FooInterface.java",
  #       "org/chromium/foo/FooService.java",
  #     ]
  #     deps = [
  #       ":bar_java"
  #     ]
  #     srcjar_deps = [
  #       ":foo_generated_enum"
  #     ]
  #     jar_excluded_patterns = [
  #       "*/FooService.class", "org/chromium/FooService\$*.class"
  #     ]
  #   }
  template("java_library") {
    java_library_impl(target_name) {
      forward_variables_from(invoker, "*")
      type = "java_library"
    }
  }

  # Declare a java library target for a prebuilt jar
  #
  # Supports all variables of java_library().
  #
  # Example
  #   java_prebuilt("foo_java") {
  #     jar_path = "foo.jar"
  #     deps = [
  #       ":foo_resources",
  #       ":bar_java"
  #     ]
  #   }
  template("java_prebuilt") {
    java_library_impl(target_name) {
      forward_variables_from(invoker, "*")
      type = "java_library"
    }
  }

  # Combines all dependent .jar files into a single .jar file.
  #
  # Variables:
  #   output: Path to the output jar.
  #   dex_path: Path to dex()'ed output (optional).
  #   override_build_config: Use a pre-existing .build_config. Must be of type
  #     "apk".
  #   use_interface_jars: Use all dependent interface .jars rather than
  #     implementation .jars.
  #   use_unprocessed_jars: Use unprocessed / undesugared .jars.
  #   direct_deps_only: Do not recurse on deps.
  #   proguard_enabled: Whether to run ProGuard on resulting jar.
  #   proguard_configs: List of proguard configs.
  #   proguard_jar_path: The path to proguard.jar you wish to use. If undefined,
  #     the proguard used will be the checked in one in //third_party/proguard.
  #   alternative_android_sdk_jar: System jar to use when proguard is enabled.
  #
  # Example
  #   dist_jar("lib_fatjar") {
  #     deps = [ ":my_java_lib" ]
  #     output = "$root_build_dir/MyLibrary.jar"
  #   }
  #   dist_jar("sideloaded_dex") {
  #     deps = [ ":my_java_lib" ]
  #     output = "$root_build_dir/MyLibrary.jar"
  #     dex_path = "$root_build_dir/MyLibrary.dex"
  #   }
  template("dist_jar") {
    forward_variables_from(invoker, [ "testonly" ])
    _supports_android =
        !defined(invoker.supports_android) || invoker.supports_android
    _requires_android =
        defined(invoker.requires_android) && invoker.requires_android
    _proguard_enabled =
        defined(invoker.proguard_enabled) && invoker.proguard_enabled
    _use_interface_jars =
        defined(invoker.use_interface_jars) && invoker.use_interface_jars
    _use_unprocessed_jars =
        defined(invoker.use_unprocessed_jars) && invoker.use_unprocessed_jars
    _direct_deps_only =
        defined(invoker.direct_deps_only) && invoker.direct_deps_only
    assert(!(_proguard_enabled && _use_interface_jars),
           "Cannot set both proguard_enabled and use_interface_jars")
    assert(!(_proguard_enabled && _direct_deps_only),
           "Cannot set both proguard_enabled and direct_deps_only")
    assert(!(_use_unprocessed_jars && _use_interface_jars),
           "Cannot set both use_interface_jars and use_unprocessed_jars")

    _jar_target_name = target_name
    if (defined(invoker.dex_path)) {
      if (_proguard_enabled) {
        _jar_target_name = "${target_name}__proguard"
      } else {
        _jar_target_name = "${target_name}__dist_jar"
      }
    }

    _deps = []
    if (defined(invoker.deps)) {
      _deps = invoker.deps
    }
    if (_supports_android) {
      _deps += [ "//third_party/android_tools:android_sdk_java" ]
    }
    _enable_build_hooks =
        _supports_android &&
        (!defined(invoker.no_build_hooks) || !invoker.no_build_hooks)
    if (_enable_build_hooks && _requires_android) {
      _deps += [ "//build/android/buildhooks:build_hooks_android_impl_java" ]
    }

    if (defined(invoker.override_build_config)) {
      _build_config = invoker.override_build_config
    } else {
      _build_config = "$target_gen_dir/$target_name.build_config"
      _build_config_target_name = "${target_name}__build_config"

      write_build_config(_build_config_target_name) {
        type = "dist_jar"
        forward_variables_from(invoker,
                               [
                                 "proguard_enabled",
                                 "proguard_configs",
                               ])
        supports_android = _supports_android
        requires_android = _requires_android
        possible_config_deps = _deps
        build_config = _build_config
      }

      _deps += [ ":$_build_config_target_name" ]
    }

    _rebased_build_config = rebase_path(_build_config, root_build_dir)
    if (_proguard_enabled) {
      proguard(_jar_target_name) {
        forward_variables_from(invoker,
                               [
                                 "data",
                                 "proguard_jar_path",
                               ])
        build_config = _build_config
        deps = _deps

        # Although these will be listed as deps in the depfile, they must also
        # appear here so that "gn analyze" knows about them.
        # https://crbug.com/827197
        inputs = []
        if (defined(invoker.proguard_configs)) {
          inputs += invoker.proguard_configs
        }

        output_jar_path = invoker.output
        args = [
          "--proguard-configs=@FileArg($_rebased_build_config:deps_info:proguard_all_configs)",
          "--input-paths=@FileArg($_rebased_build_config:deps_info:java_runtime_classpath)",
          "--classpath=@FileArg($_rebased_build_config:deps_info:proguard_all_extra_jars)",
        ]
        if (defined(invoker.proguard_config_exclusions)) {
          _rebased_proguard_config_exclusions =
              rebase_path(invoker.proguard_config_exclusions, root_build_dir)
          args += [
            "--proguard-config-exclusions=$_rebased_proguard_config_exclusions",
          ]
        }
      }
    } else {
      action(_jar_target_name) {
        forward_variables_from(invoker, [ "data" ])
        script = "//build/android/gyp/create_dist_jar.py"
        depfile = "$target_gen_dir/$target_name.d"
        deps = _deps

        inputs = [
          _build_config,
        ]

        outputs = [
          invoker.output,
        ]

        args = [
          "--depfile",
          rebase_path(depfile, root_build_dir),
          "--output",
          rebase_path(invoker.output, root_build_dir),
        ]

        if (_direct_deps_only) {
          if (_use_interface_jars) {
            args += [ "--jars=@FileArg($_rebased_build_config:javac:interface_classpath)" ]
          } else if (_use_unprocessed_jars) {
            args +=
                [ "--jars=@FileArg($_rebased_build_config:javac:classpath)" ]
          } else {
            assert(
                false,
                "direct_deps_only does not work without use_interface_jars or use_unprocessed_jars")
          }
        } else {
          if (_use_interface_jars) {
            args += [ "--jars=@FileArg($_rebased_build_config:dist_jar:all_interface_jars)" ]
          } else if (_use_unprocessed_jars) {
            args += [ "--jars=@FileArg($_rebased_build_config:deps_info:javac_full_classpath)" ]
          } else {
            args += [ "--jars=@FileArg($_rebased_build_config:deps_info:java_runtime_classpath)" ]
          }
        }
      }
    }
    if (defined(invoker.dex_path)) {
      dex(target_name) {
        deps = [
          ":$_jar_target_name",
        ]
        input_jars = [ invoker.output ]
        output = invoker.dex_path
      }
    }
  }

  # Creates an Android .aar library.
  #
  # Currently supports:
  #   * AndroidManifest.xml
  #   * classes.jar
  #   * jni/
  #   * res/
  #   * R.txt
  #   * proguard.txt
  # Does not yet support:
  #   * public.txt
  #   * annotations.zip
  #   * assets/
  # See: https://developer.android.com/studio/projects/android-library.html#aar-contents
  #
  # Variables:
  #   output: Path to the output .aar.
  #   proguard_configs: List of proguard configs (optional).
  #   android_manifest: Path to AndroidManifest.xml (optional).
  #   native_libraries: list of native libraries (optional).
  #   direct_deps_only: Do not recurse on deps. (optional, defaults false).
  #
  # Example
  #   dist_aar("my_aar") {
  #     deps = [ ":my_java_lib" ]
  #     output = "$root_build_dir/MyLibrary.aar"
  #   }
  template("dist_aar") {
    forward_variables_from(invoker, [ "testonly" ])

    _deps = []
    if (defined(invoker.deps)) {
      _deps = invoker.deps
    }

    _direct_deps_only =
        defined(invoker.direct_deps_only) && invoker.direct_deps_only

    _build_config = "$target_gen_dir/$target_name.build_config"
    _build_config_target_name = "${target_name}__build_config"

    write_build_config(_build_config_target_name) {
      type = "dist_aar"
      forward_variables_from(invoker, [ "proguard_configs" ])
      possible_config_deps = _deps
      supports_android = true
      requires_android = true
      build_config = _build_config
    }

    _deps += [ ":$_build_config_target_name" ]

    _rebased_build_config = rebase_path(_build_config, root_build_dir)

    action(target_name) {
      forward_variables_from(invoker, [ "data" ])
      depfile = "$target_gen_dir/$target_name.d"
      deps = _deps
      script = "//build/android/gyp/dist_aar.py"

      inputs = [
        _build_config,
      ]

      # Although these will be listed as deps in the depfile, they must also
      # appear here so that "gn analyze" knows about them.
      # https://crbug.com/827197
      if (defined(invoker.proguard_configs)) {
        inputs += invoker.proguard_configs
      }

      outputs = [
        invoker.output,
      ]

      args = [
        "--depfile",
        rebase_path(depfile, root_build_dir),
        "--output",
        rebase_path(invoker.output, root_build_dir),
        "--dependencies-res-zips=@FileArg($_rebased_build_config:resources:dependency_zips)",
        "--r-text-files=@FileArg($_rebased_build_config:resources:extra_r_text_files)",
        "--proguard-configs=@FileArg($_rebased_build_config:deps_info:proguard_all_configs)",
      ]
      if (_direct_deps_only) {
        args += [ "--jars=@FileArg($_rebased_build_config:javac:classpath)" ]
      } else {
        args += [ "--jars=@FileArg($_rebased_build_config:deps_info:javac_full_classpath)" ]
      }
      if (defined(invoker.android_manifest)) {
        args += [
          "--android-manifest",
          rebase_path(invoker.android_manifest, root_build_dir),
        ]
      }
      if (defined(invoker.native_libraries) && invoker.native_libraries != []) {
        inputs += invoker.native_libraries
        _rebased_native_libraries =
            rebase_path(invoker.native_libraries, root_build_dir)

        args += [
          "--native-libraries=$_rebased_native_libraries",
          "--abi=$android_app_abi",
        ]
      }
    }
  }

  # Declare an Android library target
  #
  # This target creates an Android library containing java code and Android
  # resources.
  #
  # Supports all variables of java_library(), plus:
  #   android_manifest_for_lint: Path to AndroidManifest.xml (optional). This
  #     manifest will be used by Android lint, but will not be merged into apks.
  #     To have a manifest merged, add it to an android_resources() target.
  #   deps: In addition to defining java deps, this can also include
  #     android_assets() and android_resources() targets.
  #   dex_path: If set, the resulting .dex.jar file will be placed under this
  #     path.
  #   alternative_android_sdk_ijar: if set, the given android_sdk_ijar file
  #     replaces the default android_sdk_ijar.
  #   alternative_android_sdk_ijar_dep: the target that generates
  #      alternative_android_sdk_ijar, must be set if alternative_android_sdk_ijar
  #      is used.
  #   alternative_android_sdk_jar: actual jar corresponding to
  #      alternative_android_sdk_ijar, must be set if alternative_android_sdk_ijar
  #      is used.
  #
  # Example
  #   android_library("foo_java") {
  #     java_files = [
  #       "android/org/chromium/foo/Foo.java",
  #       "android/org/chromium/foo/FooInterface.java",
  #       "android/org/chromium/foo/FooService.java",
  #     ]
  #     deps = [
  #       ":bar_java"
  #     ]
  #     srcjar_deps = [
  #       ":foo_generated_enum"
  #     ]
  #     jar_excluded_patterns = [
  #       "*/FooService.class", "org/chromium/FooService\$*.class"
  #     ]
  #   }
  template("android_library") {
    java_library(target_name) {
      forward_variables_from(invoker, "*")

      supports_android = true
      requires_android = true

      if (!defined(jar_excluded_patterns)) {
        jar_excluded_patterns = []
      }
      jar_excluded_patterns += [
        "*/R.class",
        "*/R\$*.class",
        "*/Manifest.class",
        "*/Manifest\$*.class",
      ]
    }
  }

  # Declare an Android library target for a prebuilt jar
  #
  # This target creates an Android library containing java code and Android
  # resources.
  #
  # Supports all variables of android_library().
  #
  # Example
  #   android_java_prebuilt("foo_java") {
  #     jar_path = "foo.jar"
  #     deps = [
  #       ":foo_resources",
  #       ":bar_java"
  #     ]
  #   }
  template("android_java_prebuilt") {
    android_library(target_name) {
      forward_variables_from(invoker, "*")
    }
  }

  template("android_system_java_prebuilt") {
    java_library_impl(target_name) {
      forward_variables_from(invoker, "*")
      no_build_hooks = true
      supports_android = true
      type = "system_java_library"
    }
  }

  # Creates org/chromium/base/BuildConfig.java
  # This doesn't really belong in //build since it genates a file for //base.
  # However, we don't currently have a better way to include this file in all
  # apks that depend on //base:base_java.
  #
  # Variables:
  #   use_final_fields: True to use final fields. All other variables are
  #       ignored when this is false.
  #   build_config: Path to build_config used for locale list
  #   enable_multidex: Value for ENABLE_MULTIDEX.
  #   firebase_app_id: Value for FIREBASE_APP_ID.
  #
  template("generate_build_config_srcjar") {
    java_cpp_template(target_name) {
      package_path = "org/chromium/base"
      sources = [
        "//base/android/java/templates/BuildConfig.template",
      ]
      defines = []

      # TODO(agrieve): These two are not target-specific and should be moved
      #     to BuildHooks.java.
      # Set these even when !use_final_fields so that they have correct default
      # values withnin junit_binary().
      if (is_java_debug || dcheck_always_on) {
        defines += [ "_DCHECK_IS_ON" ]
      }
      if (use_cfi_diag || is_ubsan || is_ubsan_security || is_ubsan_vptr) {
        defines += [ "_IS_UBSAN" ]
      }

      if (invoker.use_final_fields) {
        forward_variables_from(invoker,
                               [
                                 "deps",
                                 "testonly",
                               ])
        defines += [ "USE_FINAL" ]
        if (invoker.enable_multidex) {
          defines += [ "ENABLE_MULTIDEX" ]
        }
        inputs = [
          invoker.build_config,
        ]
        _rebased_build_config = rebase_path(invoker.build_config)
        defines += [
          "COMPRESSED_LOCALE_LIST=" +
              "@FileArg($_rebased_build_config:compressed_locales_java_list)",
          "UNCOMPRESSED_LOCALE_LIST=" +
              "@FileArg($_rebased_build_config:uncompressed_locales_java_list)",
        ]
        if (defined(invoker.firebase_app_id)) {
          defines += [ "_FIREBASE_APP_ID=${invoker.firebase_app_id}" ]
        }
        if (defined(invoker.resources_version_variable)) {
          defines += [
            "_RESOURCES_VERSION_VARIABLE=${invoker.resources_version_variable}",
          ]
        }
      }
    }
  }

  # Declare an Android apk target
  #
  # This target creates an Android APK containing java code, resources, assets,
  # and (possibly) native libraries.
  #
  # Supports all variables of android_library(), plus:
  #   android_manifest: Path to AndroidManifest.xml.
  #   android_manifest_dep: Target that generates AndroidManifest (if applicable)
  #   png_to_webp: If true, pngs (with the exception of 9-patch) are
  #     converted to webp during resource packaging.
  #   dist_ijar_path: Path to create "${target_name}_dist_ijar" target
  #     (used by instrumentation_test_apk).
  #   apk_name: Name for final apk.
  #   final_apk_path: Path to final built apk. Default is
  #     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
  #   loadable_modules: List of paths to native libraries to include. Different
  #     from |shared_libraries| in that:
  #       * dependencies of this .so are not automatically included
  #       * ".cr.so" is never added
  #       * they are not side-loaded for _incremental targets.
  #       * load_library_from_apk, use_chromium_linker,
  #         and enable_relocation_packing do not apply
  #     Use this instead of shared_libraries when you are going to load the library
  #     conditionally, and only when shared_libraries doesn't work for you.
  #   shared_libraries: List shared_library targets to bundle. If these
  #     libraries depend on other shared_library targets, those dependencies will
  #     also be included in the apk (e.g. for is_component_build).
  #   secondary_abi_shared_libraries: secondary abi shared_library targets to
  #     bundle. If these libraries depend on other shared_library targets, those
  #     dependencies will also be included in the apk (e.g. for is_component_build).
  #   native_lib_placeholders: List of placeholder filenames to add to the apk
  #     (optional).
  #   secondary_native_lib_placeholders: List of placeholder filenames to add to
  #     the apk for the secondary ABI (optional).
  #   apk_under_test: For an instrumentation test apk, this is the target of the
  #     tested apk.
  #   write_asset_list: Adds an extra file to the assets, which contains a list of
  #     all other asset files.
  #   generate_buildconfig_java: If defined and false, skip generating the
  #     BuildConfig java class describing the build configuration. The default
  #     is true for non-test APKs.
  #   firebase_app_id: The value for BuildConfig.FIREBASE_APP_ID (optional).
  #     Identifier is sent with crash reports to enable Java stack deobfuscation.
  #   requires_sdk_api_level_23: If defined and true, the apk is intended for
  #     installation only on Android M or later. In these releases the system
  #     linker does relocation unpacking, so we can enable it unconditionally.
  #   secondary_native_libs (deprecated): The path of native libraries for secondary
  #     app abi.
  #   proguard_jar_path: The path to proguard.jar you wish to use. If undefined,
  #     the proguard used will be the checked in one in //third_party/proguard.
  #   never_incremental: If true, |incremental_apk_by_default| will be ignored.
  #   aapt_locale_whitelist: If set, all locales not in this list will be
  #     stripped from resources.arsc.
  #   exclude_xxxhdpi: Causes all drawable-xxxhdpi images to be excluded
  #     (mipmaps are still included).
  #   xxxhdpi_whitelist: A list of globs used when exclude_xxxhdpi=true. Files
  #     that match this whitelist will still be included.
  #   shared_resources: True if this is a runtime shared library APK, like
  #     the system_webview_apk target. Ensures that its resources can be
  #     used by the loading application process.
  #   app_as_shared_lib: True if this is a regular application apk that can
  #     also serve as a runtime shared library, like the monochrome_public_apk
  #     target. Ensures that the resources are usable both by the APK running
  #     as an application, or by another process that loads it at runtime.
  #   shared_resources_whitelist_target: Optional name of a target specifying
  #     an input R.txt file that lists the resources that can be exported
  #     by the APK when shared_resources or app_as_shared_lib is defined.
  #
  # Example
  #   android_apk("foo_apk") {
  #     android_manifest = "AndroidManifest.xml"
  #     java_files = [
  #       "android/org/chromium/foo/FooApplication.java",
  #       "android/org/chromium/foo/FooActivity.java",
  #     ]
  #     deps = [
  #       ":foo_support_java"
  #       ":foo_resources"
  #     ]
  #     srcjar_deps = [
  #       ":foo_generated_enum"
  #     ]
  #     shared_libraries = [
  #       ":my_shared_lib",
  #     ]
  #   }
  template("android_apk") {
    forward_variables_from(invoker, [ "testonly" ])

    assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
    assert(defined(invoker.android_manifest))
    _gen_dir = "$target_gen_dir/$target_name"
    _base_path = "$_gen_dir/$target_name"
    _build_config = "$target_gen_dir/$target_name.build_config"
    _build_config_target = "${target_name}__build_config"

    # JUnit tests use resource zip files. These must not be put in gen/
    # directory or they will not be available to tester bots.
    _jar_path = "$_base_path.jar"
    _lib_dex_path = "$_base_path.dex.jar"
    _rebased_lib_dex_path = rebase_path(_lib_dex_path, root_build_dir)
    _template_name = target_name

    _enable_multidex =
        defined(invoker.enable_multidex) && invoker.enable_multidex
    if (_enable_multidex) {
      _final_dex_path = "$_gen_dir/classes.dex.zip"
    } else {
      _final_dex_path = "$_gen_dir/classes.dex"
    }
    _final_dex_target_name = "${_template_name}__final_dex"

    if (defined(invoker.final_apk_path)) {
      _final_apk_path = invoker.final_apk_path
    } else {
      _final_apk_path = "$root_build_dir/apks/${invoker.apk_name}.apk"
    }
    _final_apk_path_no_ext_list =
        process_file_template([ _final_apk_path ],
                              "{{source_dir}}/{{source_name_part}}")
    _final_apk_path_no_ext = _final_apk_path_no_ext_list[0]
    assert(_final_apk_path_no_ext != "")  # Mark as used.

    # resource_sizes.py needs to be able to find the unpacked resources.arsc file based on apk name.
    _packaged_resources_path =
        "$root_gen_dir/arsc/" +
        rebase_path(_final_apk_path_no_ext, root_build_dir) + ".ap_"

    _incremental_install_json_path =
        "$target_gen_dir/$target_name.incremental.json"

    _version_code = android_default_version_code
    if (defined(invoker.version_code)) {
      _version_code = invoker.version_code
    }

    _version_name = android_default_version_name
    if (defined(invoker.version_name)) {
      _version_name = invoker.version_name
    }
    _keystore_path = android_keystore_path
    _keystore_name = android_keystore_name
    _keystore_password = android_keystore_password

    if (defined(invoker.keystore_path)) {
      _keystore_path = invoker.keystore_path
      _keystore_name = invoker.keystore_name
      _keystore_password = invoker.keystore_password
    }

    _deps = []
    if (defined(invoker.deps)) {
      _deps = invoker.deps
      set_sources_assignment_filter([ "*manifest*" ])
      sources = _deps
      set_sources_assignment_filter([])
      if (sources != _deps) {
        _bad_deps = _deps - sources
        assert(
            false,
            "Possible manifest-generating dep found in deps. Use android_manifest_dep for this instead. Found: $_bad_deps")
      }
      sources = []
    }

    _srcjar_deps = []
    if (defined(invoker.srcjar_deps)) {
      _srcjar_deps = invoker.srcjar_deps
    }

    _use_build_hooks =
        !defined(invoker.no_build_hooks) || !invoker.no_build_hooks
    if (defined(invoker.build_hooks_android_impl_deps)) {
      assert(_use_build_hooks,
             "Cannot set no_build_hooks and build_hooks_android_impl_deps at " +
                 "the same time")
      _deps += invoker.build_hooks_android_impl_deps
    } else if (_use_build_hooks) {
      _deps += [ "//build/android/buildhooks:build_hooks_android_impl_java" ]
    }

    _android_root_manifest_deps = []
    if (defined(invoker.android_manifest_dep)) {
      _android_root_manifest_deps = [ invoker.android_manifest_dep ]
    }
    _android_root_manifest = invoker.android_manifest

    _use_chromium_linker =
        defined(invoker.use_chromium_linker) && invoker.use_chromium_linker
    _pack_relocations =
        defined(invoker.pack_relocations) && invoker.pack_relocations

    _load_library_from_apk =
        defined(invoker.load_library_from_apk) && invoker.load_library_from_apk
    _requires_sdk_api_level_23 = defined(invoker.requires_sdk_api_level_23) &&
                                 invoker.requires_sdk_api_level_23

    assert(_use_chromium_linker || true)  # Mark as used.
    assert(_requires_sdk_api_level_23 || true)
    assert(!_pack_relocations || !use_lld,
           "Use //build/config/android:lld_pack_relocations to pack " +
               "relocations when use_lld=true.")
    assert(!_pack_relocations || _use_chromium_linker ||
               _requires_sdk_api_level_23,
           "pack_relocations requires either use_chromium_linker " +
               "or requires_sdk_api_level_23")
    assert(!_load_library_from_apk || _use_chromium_linker ||
               _requires_sdk_api_level_23,
           "load_library_from_apk requires use_chromium_linker " +
               "or requires_sdk_api_level_23")

    # The dependency that makes the chromium linker, if any is needed.
    _native_libs_deps = []
    _shared_libraries_is_valid =
        defined(invoker.shared_libraries) && invoker.shared_libraries != []
    _secondary_abi_native_libs_deps = []
    assert(_secondary_abi_native_libs_deps == [])  # mark as used.
    _secondary_abi_shared_libraries_is_valid =
        defined(invoker.secondary_abi_shared_libraries) &&
        invoker.secondary_abi_shared_libraries != []

    if (is_component_build || is_asan) {
      if (_shared_libraries_is_valid) {
        _native_libs_deps += [ "//build/android:cpplib_stripped" ]
      }
      if (_secondary_abi_shared_libraries_is_valid) {
        _secondary_abi_native_libs_deps += [
          "//build/android:cpplib_stripped($android_secondary_abi_toolchain)",
        ]
      }
    }

    if (_shared_libraries_is_valid) {
      _native_libs_deps += invoker.shared_libraries

      # To determine the filenames of all dependent shared libraries, write the
      # runtime deps of |shared_libraries| to a file during "gn gen".
      # write_build_config.py will then grep this file for *.so to obtain the
      # complete list.
      _runtime_deps_file =
          "$target_gen_dir/${_template_name}.native.runtimedeps"
      group("${_template_name}__runtime_deps") {
        deps = _native_libs_deps
        write_runtime_deps = _runtime_deps_file
      }

      _native_lib_version_rule = ""
      if (defined(invoker.native_lib_version_rule)) {
        _native_lib_version_rule = invoker.native_lib_version_rule
      }
      _native_lib_version_arg = "\"\""
      if (defined(invoker.native_lib_version_arg)) {
        _native_lib_version_arg = invoker.native_lib_version_arg
      }
    } else {
      # Must exist for instrumentation_test_apk() to depend on.
      group("${_template_name}__runtime_deps") {
      }
    }

    if (_secondary_abi_shared_libraries_is_valid) {
      _secondary_abi_native_libs_deps += invoker.secondary_abi_shared_libraries

      # To determine the filenames of all dependent shared libraries, write the
      # runtime deps of |shared_libraries| to a file during "gn gen".
      # write_build_config.py will then grep this file for *.so to obtain the
      # complete list.
      _secondary_abi_runtime_deps_file =
          "$target_gen_dir/${_template_name}.secondary.abi.native.runtimedeps"
      group("${_template_name}__secondary_abi__runtime_deps") {
        deps = _secondary_abi_native_libs_deps
        write_runtime_deps = _secondary_abi_runtime_deps_file
      }
    } else {
      # Must exist for instrumentation_test_apk() to depend on.
      group("${_template_name}__secondary_abi_runtime_deps") {
      }
    }

    _rebased_build_config = rebase_path(_build_config, root_build_dir)

    _generate_buildconfig_java = !defined(invoker.apk_under_test)
    if (defined(invoker.generate_buildconfig_java)) {
      _generate_buildconfig_java = invoker.generate_buildconfig_java
    }

    _proguard_enabled =
        defined(invoker.proguard_enabled) && invoker.proguard_enabled
    if (_proguard_enabled) {
      _proguard_output_jar_path = "$_base_path.proguard.jar"
    }

    _incremental_allowed =
        !(defined(invoker.never_incremental) && invoker.never_incremental)

    _android_manifest =
        "$target_gen_dir/${_template_name}_manifest/AndroidManifest.xml"
    _merge_manifest_target = "${_template_name}__merge_manifests"
    merge_manifests(_merge_manifest_target) {
      input_manifest = _android_root_manifest
      output_manifest = _android_manifest
      build_config = _build_config
      deps = _android_root_manifest_deps + [ ":$_build_config_target" ]
    }

    _final_deps = []

    if (_enable_multidex) {
      _generated_proguard_main_dex_config =
          "$_base_path.resources.main-dex-proguard.txt"
    }
    _generated_proguard_config = "$_base_path.resources.proguard.txt"

    if (_generate_buildconfig_java &&
        defined(invoker.product_version_resources_dep)) {
      _deps += [ invoker.product_version_resources_dep ]
    }

    _compile_resources_target = "${_template_name}__compile_resources"

    if (android_enable_app_bundles) {
      # Path to the intermediate proto-format resources zip file.
      _packaged_proto_resources_path =
          "$root_gen_dir/proto_resources/" +
          rebase_path(_final_apk_path_no_ext, root_build_dir) + ".proto.ap_"

      # Define another target used to generate an archive containing the
      # resources compiled in protocol buffer format. This is not used by
      # the APK itself, but by android_bundle_module() targets that depend
      # on it.
      _compile_proto_resources_target =
          "${_template_name}__compile_proto_resources"
    }

    compile_apk_resources(_compile_resources_target) {
      forward_variables_from(invoker,
                             [
                               "app_as_shared_lib",
                               "shared_resources",
                               "support_zh_hk",
                               "aapt_locale_whitelist",
                               "exclude_xxxhdpi",
                               "png_to_webp",
                               "xxxhdpi_whitelist",
                               "no_xml_namespaces",
                             ])
      android_manifest = _android_manifest
      version_code = _version_code
      version_name = _version_name

      # Subtle: required to avoid GN build errors. "testonly" cannot be added
      # to the forward_variables_from() above because it was already forwarded
      # at the start of android_apk(). And if the assignment below is not
      # performed, GN will complain that some test-only targets depend
      # on non-test-only ones.
      testonly = defined(testonly) && testonly

      if (defined(invoker.post_process_package_resources_script)) {
        post_process_script = invoker.post_process_package_resources_script
      }
      srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
      r_text_out_path = "${target_gen_dir}/${target_name}_R.txt"
      proguard_file = _generated_proguard_config
      if (_enable_multidex) {
        proguard_file_main_dex = _generated_proguard_main_dex_config
      }
      output = _packaged_resources_path

      build_config = _build_config
      deps = _deps + [
               ":$_merge_manifest_target",
               ":$_build_config_target",
             ]
      if (defined(invoker.shared_resources_whitelist_target)) {
        _whitelist_gen_dir =
            get_label_info(invoker.shared_resources_whitelist_target,
                           "target_gen_dir")
        _whitelist_target_name =
            get_label_info(invoker.shared_resources_whitelist_target, "name")
        shared_resources_whitelist =
            "${_whitelist_gen_dir}/${_whitelist_target_name}" +
            "__compile_resources_R.txt"
        deps += [
          "${invoker.shared_resources_whitelist_target}__compile_resources",
        ]
      }

      if (android_enable_app_bundles) {
        proto_output = _packaged_proto_resources_path
        proto_resources_target = _compile_proto_resources_target
      }
    }
    _srcjar_deps += [ ":$_compile_resources_target" ]

    if (_native_libs_deps != []) {
      _enable_chromium_linker_tests = false
      if (defined(invoker.enable_chromium_linker_tests)) {
        _enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
      }
      _ordered_libraries_json =
          "$target_gen_dir/$target_name.ordered_libararies.json"
      _rebased_ordered_libraries_json =
          rebase_path(_ordered_libraries_json, root_build_dir)
      _ordered_libraries_target = "${_template_name}__write_ordered_libraries"

      # TODO(agrieve): Make GN write runtime deps in dependency order so as to
      # not need this manual sorting step.
      action(_ordered_libraries_target) {
        script = "//build/android/gyp/write_ordered_libraries.py"
        deps = [
          ":$_build_config_target",
          ":${_template_name}__runtime_deps",
        ]
        inputs = [
          _runtime_deps_file,
        ]
        outputs = [
          _ordered_libraries_json,
        ]
        _rebased_android_readelf = rebase_path(android_readelf, root_build_dir)
        args = [
          "--readelf=$_rebased_android_readelf",
          "--output=$_rebased_ordered_libraries_json",
          "--runtime-deps=" + rebase_path(_runtime_deps_file, root_build_dir),
        ]
        if (defined(invoker.dont_load_shared_libraries)) {
          args += [ "--exclude-shared-libraries=" +
                    invoker.dont_load_shared_libraries ]
        }
      }

      java_cpp_template("${_template_name}__native_libraries_java") {
        package_path = "org/chromium/base/library_loader"
        sources = [
          "//base/android/java/templates/NativeLibraries.template",
        ]
        inputs = [
          _ordered_libraries_json,
        ]
        deps = [
          ":${_ordered_libraries_target}",
        ]
        if (_native_lib_version_rule != "") {
          deps += [ _native_lib_version_rule ]
        }

        defines = [
          "NATIVE_LIBRARIES_LIST=" +
              "@FileArg($_rebased_ordered_libraries_json:java_libraries_list)",
          "NATIVE_LIBRARIES_VERSION_NUMBER=$_native_lib_version_arg",
        ]
        if (current_cpu == "arm" || current_cpu == "arm64") {
          defines += [ "ANDROID_APP_CPU_FAMILY_ARM" ]
        } else if (current_cpu == "x86" || current_cpu == "x64") {
          defines += [ "ANDROID_APP_CPU_FAMILY_X86" ]
        } else if (current_cpu == "mipsel" || current_cpu == "mips64el") {
          defines += [ "ANDROID_APP_CPU_FAMILY_MIPS" ]
        } else {
          assert(false, "Unsupported CPU family")
        }
        if (_use_chromium_linker) {
          defines += [ "ENABLE_CHROMIUM_LINKER" ]
        }
        if (_load_library_from_apk) {
          defines += [ "ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE" ]
        }
        if (_enable_chromium_linker_tests) {
          defines += [ "ENABLE_CHROMIUM_LINKER_TESTS" ]
        }
      }
      _srcjar_deps += [ ":${_template_name}__native_libraries_java" ]
    }

    _extra_native_libs = _sanitizer_runtimes
    _extra_native_libs_deps = []
    assert(_extra_native_libs_deps == [])  # Mark as used.
    if (_native_libs_deps != []) {
      if (_use_chromium_linker) {
        _extra_native_libs +=
            [ "$root_shlib_dir/libchromium_android_linker$shlib_extension" ]
        _extra_native_libs_deps +=
            [ "//base/android/linker:chromium_android_linker" ]
      }
    }

    if (_generate_buildconfig_java) {
      generate_build_config_srcjar("${_template_name}__build_config_java") {
        forward_variables_from(invoker, [ "firebase_app_id" ])
        use_final_fields = true
        build_config = _build_config
        enable_multidex = _enable_multidex
        if (defined(invoker.product_version_resources_dep)) {
          resources_version_variable =
              "org.chromium.base.R.string.product_version"
        }
        deps = [
          ":$_build_config_target",
        ]
      }
      _srcjar_deps += [ ":${_template_name}__build_config_java" ]
    }

    _java_target = "${_template_name}__java"
    java_library_impl(_java_target) {
      forward_variables_from(invoker,
                             [
                               "alternative_android_sdk_dep",
                               "android_manifest",
                               "android_manifest_dep",
                               "apk_under_test",
                               "chromium_code",
                               "classpath_deps",
                               "emma_never_instrument",
                               "java_files",
                               "no_build_hooks",
                               "javac_args",
                               "uncompress_shared_libraries",
                             ])
      type = "android_apk"
      main_target_name = _template_name
      supports_android = true
      requires_android = true
      deps = _deps

      srcjar_deps = _srcjar_deps
      final_jar_path = _jar_path
      dex_path = _lib_dex_path
      final_dex_path = _final_dex_path
      apk_path = _final_apk_path

      if (android_enable_app_bundles) {
        proto_resources_path = _packaged_proto_resources_path
      }

      incremental_allowed = _incremental_allowed
      incremental_apk_path = "${_final_apk_path_no_ext}_incremental.apk"
      incremental_install_json_path = _incremental_install_json_path

      proguard_enabled = _proguard_enabled
      if (_proguard_enabled) {
        proguard_configs = [ _generated_proguard_config ]
        if (defined(invoker.proguard_configs)) {
          proguard_configs += invoker.proguard_configs
        }
        if (_enable_multidex) {
          proguard_configs += [ "//build/android/multidex.flags" ]
        }
        proguard_output_jar_path = _proguard_output_jar_path
      }
      non_native_packed_relocations = _pack_relocations

      # Don't depend on the runtime_deps target in order to avoid having to
      # build the native libraries just to create the .build_config file.
      # The dep is unnecessary since the runtime_deps file is created by gn gen
      # and the runtime_deps file is added to write_build_config.py's depfile.
      if (_native_libs_deps != []) {
        shared_libraries_runtime_deps_file = _runtime_deps_file
      }
      if (_secondary_abi_native_libs_deps != []) {
        secondary_abi_shared_libraries_runtime_deps_file =
            _secondary_abi_runtime_deps_file
      }

      extra_shared_libraries = _extra_native_libs
    }

    # TODO(cjhopman): This is only ever needed to calculate the list of tests to
    # run. See build/android/pylib/instrumentation/test_jar.py. We should be
    # able to just do that calculation at build time instead.
    if (defined(invoker.dist_ijar_path)) {
      _dist_ijar_path = invoker.dist_ijar_path
      dist_jar("${_template_name}_dist_ijar") {
        override_build_config = _build_config
        output = _dist_ijar_path
        data = [
          _dist_ijar_path,
        ]
        use_interface_jars = true
        deps = [
          ":$_build_config_target",
          ":$_java_target",
        ]
      }
    }

    if (_proguard_enabled) {
      _proguard_target = "${_template_name}__proguard"
      proguard(_proguard_target) {
        forward_variables_from(invoker, [ "proguard_jar_path" ])
        build_config = _build_config
        deps = _deps + [
                 ":$_build_config_target",
                 ":$_compile_resources_target",
                 ":$_java_target",
               ]
        inputs = [
          _jar_path,
        ]

        output_jar_path = _proguard_output_jar_path
        args = [
          "--proguard-configs=@FileArg($_rebased_build_config:deps_info:proguard_all_configs)",
          "--input-paths=@FileArg($_rebased_build_config:deps_info:java_runtime_classpath)",
          "--classpath=@FileArg($_rebased_build_config:deps_info:proguard_all_extra_jars)",
        ]
        if (defined(invoker.proguard_config_exclusions)) {
          _rebased_proguard_config_exclusions =
              rebase_path(invoker.proguard_config_exclusions, root_build_dir)
          args += [
            "--proguard-config-exclusions=$_rebased_proguard_config_exclusions",
          ]
        }
        if (defined(invoker.apk_under_test)) {
          args += [ "--mapping=@FileArg($_rebased_build_config:deps_info:proguard_under_test_mapping)" ]
          deps += [ "${invoker.apk_under_test}__proguard" ]
        }
      }
      _dex_sources = [ _proguard_output_jar_path ]
      _dex_deps = [ ":$_proguard_target" ]

      _copy_proguard_mapping_target = "${_template_name}__copy_proguard_mapping"
      copy(_copy_proguard_mapping_target) {
        sources = [
          "$_proguard_output_jar_path.mapping",
        ]
        outputs = [
          "$_final_apk_path.mapping",
        ]
        deps = [
          ":$_proguard_target",
        ]
      }
    } else {
      if (_enable_multidex) {
        # .jar already included in java_runtime_classpath.
        _dex_sources = []
      } else {
        _dex_sources = [ _lib_dex_path ]
      }
      _dex_deps = [ ":$_java_target" ]
    }

    dex("$_final_dex_target_name") {
      deps = _dex_deps + [ ":$_build_config_target" ]
      input_jars = _dex_sources
      output = _final_dex_path
      enable_multidex = _enable_multidex

      if (_enable_multidex) {
        forward_variables_from(invoker, [ "negative_main_dex_globs" ])
        extra_main_dex_proguard_config = _generated_proguard_main_dex_config
        deps += [ ":$_compile_resources_target" ]
      }

      # All deps are already included in _dex_sources when proguard is used.
      if (!_proguard_enabled) {
        if (_enable_multidex) {
          _dex_arg_key =
              "${_rebased_build_config}:deps_info:java_runtime_classpath"
        } else {
          _dex_arg_key =
              "${_rebased_build_config}:final_dex:dependency_dex_files"
        }
        build_config = _build_config
        input_jars_file_arg = "@FileArg($_dex_arg_key)"
      }

      # http://crbug.com/725224. Fix for bots running out of memory.
      use_pool = true
    }

    _native_libs_file_arg_dep = ":$_build_config_target"
    _native_libs_file_arg = "@FileArg($_rebased_build_config:native:libraries)"
    _secondary_abi_native_libs_file_arg_dep = ":$_build_config_target"
    _secondary_abi_native_libs_file_arg =
        "@FileArg($_rebased_build_config:native:secondary_abi_libraries)"
    assert(_secondary_abi_native_libs_file_arg != "" &&
           _secondary_abi_native_libs_file_arg_dep != "")  # Mark as used.

    if (_native_libs_deps != [] && _pack_relocations) {
      _prepare_native_target_name = "${_template_name}__prepare_native"
      _native_libs_json = "$_gen_dir/packed-libs/filelist.json"
      _rebased_native_libs_json = rebase_path(_native_libs_json, root_build_dir)
      _native_libs_file_arg_dep = ":$_prepare_native_target_name"
      _native_libs_file_arg = "@FileArg($_rebased_native_libs_json:files)"

      pack_relocation_section(_prepare_native_target_name) {
        file_list_json = _native_libs_json
        libraries_filearg =
            "@FileArg(${_rebased_build_config}:native:libraries)"
        inputs = [
          _build_config,
        ]

        deps = _native_libs_deps
        deps += [ ":$_build_config_target" ]
      }
      if (_secondary_abi_native_libs_deps != []) {
        _prepare_native_target_name =
            "${_template_name}_secondary_abi__prepare_native"
        _native_libs_json =
            "$_gen_dir/packed-libs/$android_secondary_abi_cpu/filelist.json"
        _rebased_native_libs_json =
            rebase_path(_native_libs_json, root_build_dir)
        _secondary_abi_native_libs_file_arg_dep =
            ":$_prepare_native_target_name"
        _secondary_abi_native_libs_file_arg =
            "@FileArg($_rebased_native_libs_json:files)"

        pack_relocation_section(_prepare_native_target_name) {
          file_list_json = _native_libs_json
          libraries_filearg = "@FileArg(${_rebased_build_config}:native:secondary_abi_libraries)"
          inputs = [
            _build_config,
          ]

          deps = _secondary_abi_native_libs_deps
          deps += [ ":$_build_config_target" ]
        }
      }
    }

    _extra_native_libs_even_when_incremental = []
    if (_native_libs_deps != []) {
      _create_stack_script_rule_name = "${_template_name}__stack_script"
      _final_deps += [ ":${_create_stack_script_rule_name}" ]
      stack_script(_create_stack_script_rule_name) {
        stack_target_name = invoker.target_name
        deps = _native_libs_deps
        if (_native_libs_deps != [] && _pack_relocations) {
          packed_libraries = _native_libs_file_arg
          deps += [ _native_libs_file_arg_dep ]
        }
      }
    }

    if (defined(invoker.loadable_modules) && invoker.loadable_modules != []) {
      _extra_native_libs_even_when_incremental += invoker.loadable_modules
    }

    # Generate .apk.jar.info files if needed.
    if (defined(invoker.apk_name)) {
      _apk_jar_info_target = "${target_name}__apk_jar_info"
      create_apk_jar_info(_apk_jar_info_target) {
        output = "$root_build_dir/size-info/${invoker.apk_name}.apk.jar.info"
        apk_build_config = _build_config
        deps = [
          ":$_build_config_target",
          ":$_java_target",
        ]
      }
      _deps += [ ":$_apk_jar_info_target" ]
    }

    _final_deps += [ ":${_template_name}__create" ]
    create_apk("${_template_name}__create") {
      forward_variables_from(invoker,
                             [
                               "public_deps",
                               "secondary_native_libs",
                               "shared_resources",
                               "uncompress_shared_libraries",
                               "write_asset_list",
                             ])
      packaged_resources_path = _packaged_resources_path
      apk_path = _final_apk_path
      assets_build_config = _build_config
      dex_path = _final_dex_path
      load_library_from_apk = _load_library_from_apk

      # This is used to generate *.apk.pak.info files.
      apk_name = invoker.apk_name

      keystore_name = _keystore_name
      keystore_path = _keystore_path
      keystore_password = _keystore_password

      incremental_allowed = _incremental_allowed
      if (_incremental_allowed) {
        android_manifest = _android_manifest
        base_path = _base_path
      }

      # Incremental apk does not use native libs nor final dex.
      incremental_deps = _deps + [
                           ":$_merge_manifest_target",
                           ":$_build_config_target",
                           ":$_compile_resources_target",
                         ]

      # This target generates the input file _all_resources_zip_path.
      deps = _deps + [
               ":$_merge_manifest_target",
               ":$_build_config_target",
               ":$_final_dex_target_name",
               ":$_compile_resources_target",
             ]

      if (_native_libs_deps != [] ||
          _extra_native_libs_even_when_incremental != []) {
        deps += _native_libs_deps + _extra_native_libs_deps +
                [ _native_libs_file_arg_dep ]
        native_libs_filearg = _native_libs_file_arg
        native_libs = _extra_native_libs
        native_libs_even_when_incremental =
            _extra_native_libs_even_when_incremental
      }

      if (_secondary_abi_native_libs_deps != []) {
        deps += _secondary_abi_native_libs_deps +
                [ _secondary_abi_native_libs_file_arg_dep ]
        secondary_abi_native_libs_filearg = _secondary_abi_native_libs_file_arg
      }

      # Placeholders necessary for some older devices.
      # http://crbug.com/395038
      forward_variables_from(invoker,
                             [
                               "native_lib_placeholders",
                               "secondary_native_lib_placeholders",
                             ])
    }

    _write_installer_json_rule_name = "${_template_name}__incremental_json"
    action(_write_installer_json_rule_name) {
      script = "//build/android/incremental_install/write_installer_json.py"
      depfile = "$target_gen_dir/$target_name.d"
      deps = [
        _native_libs_file_arg_dep,
      ]

      outputs = [
        _incremental_install_json_path,
      ]

      _rebased_apk_path_no_ext =
          rebase_path(_final_apk_path_no_ext, root_build_dir)
      _rebased_incremental_install_json_path =
          rebase_path(_incremental_install_json_path, root_build_dir)
      _rebased_depfile = rebase_path(depfile, root_build_dir)
      _dex_arg_key = "${_rebased_build_config}:final_dex:dependency_dex_files"
      args = [
        "--apk-path=${_rebased_apk_path_no_ext}_incremental.apk",
        "--output-path=$_rebased_incremental_install_json_path",
        "--dex-file=$_rebased_lib_dex_path",
        "--dex-file-list=@FileArg($_dex_arg_key)",
        "--depfile=$_rebased_depfile",
      ]
      if (_proguard_enabled) {
        args += [ "--show-proguard-warning" ]
      }
      if (defined(_native_libs_file_arg)) {
        args += [ "--native-libs=$_native_libs_file_arg" ]
      }
      if (_extra_native_libs != []) {
        # Don't pass in _extra_native_libs_even_when_incremental, since these are
        # end up in the apk and are not side-loaded.
        _rebased_extra_native_libs =
            rebase_path(_extra_native_libs, root_build_dir)
        args += [ "--native-libs=$_rebased_extra_native_libs" ]
      }
      if (_load_library_from_apk) {
        args += [ "--dont-even-try=Incremental builds do not work with load_library_from_apk. Try setting is_component_build=true in your GN args." ]
      }
    }

    _apk_operations = []
    _incremental_apk_operations = []

    # Generate apk operation related script.
    if (!defined(invoker.create_apk_script) || invoker.create_apk_script) {
      _apk_operations_target_name = "${target_name}__apk_operations"
      action(_apk_operations_target_name) {
        _generated_script = "$root_build_dir/bin/${invoker.target_name}"
        script = "//build/android/gyp/create_apk_operations_script.py"
        outputs = [
          _generated_script,
        ]
        if (_proguard_enabled) {
          # Required by logcat command.
          data_deps = [
            "//build/android/stacktrace:java_deobfuscate",
          ]
        }
        args = [
          "--script-output-path",
          rebase_path(_generated_script, root_build_dir),
          "--apk-path",
          rebase_path(_final_apk_path, root_build_dir),
          "--target-cpu=$target_cpu",
        ]
        if (defined(invoker.command_line_flags_file)) {
          args += [
            "--command-line-flags-file",
            invoker.command_line_flags_file,
          ]
        }
        if (_incremental_allowed) {
          args += [
            "--incremental-install-json-path",
            rebase_path(_incremental_install_json_path, root_build_dir),
          ]
        }
        if (_proguard_enabled) {
          args += [
            "--proguard-mapping-path",
            rebase_path("$_final_apk_path.mapping", root_build_dir),
          ]
        }
      }
      _apk_operations += [ ":$_apk_operations_target_name" ]
      _incremental_apk_operations += [ ":$_apk_operations_target_name" ]
    }

    group(target_name) {
      if (_incremental_allowed && incremental_apk_by_default) {
        deps = [
          ":${target_name}_incremental",
        ]
        assert(_apk_operations != [] || true)  # Prevent "unused variable".
      } else {
        forward_variables_from(invoker,
                               [
                                 "data",
                                 "data_deps",
                               ])
        public_deps = _final_deps

        # Generate apk related operations at runtime.
        public_deps += _apk_operations

        # Make the proguard .mapping file easy to find by putting it beside the .apk.
        if (_proguard_enabled) {
          deps = [
            ":$_copy_proguard_mapping_target",
          ]
        }
      }
    }

    if (_incremental_allowed) {
      group("${target_name}_incremental") {
        forward_variables_from(invoker,
                               [
                                 "data",
                                 "data_deps",
                               ])
        if (!defined(data_deps)) {
          data_deps = []
        }

        # device/commands is used by the installer script to push files via .zip.
        data_deps += [ "//build/android/pylib/device/commands" ] +
                     _native_libs_deps + _extra_native_libs_deps

        # Since the _incremental.apk does not include use .so nor .dex from the
        # actual target, but instead loads them at runtime, we need to explicitly
        # depend on them here.
        public_deps = [
          ":${_java_target}",
          ":${_template_name}__create_incremental",
          ":${_write_installer_json_rule_name}",
        ]

        # Generate incremental apk related operations at runtime.
        public_deps += _incremental_apk_operations
      }
    }
  }

  # Declare an Android instrumentation test apk
  #
  # This target creates an Android instrumentation test apk.
  #
  # Variables
  #   android_manifest: Path to AndroidManifest.xml.
  #   data_deps: List of dependencies needed at runtime. These will be built but
  #     won't change the generated .apk in any way (in fact they may be built
  #     after the .apk is).
  #   deps: List of dependencies. All Android java resources and libraries in the
  #     "transitive closure" of these dependencies will be included in the apk.
  #     Note: this "transitive closure" actually only includes such targets if
  #     they are depended on through android_library or android_resources targets
  #     (and so not through builtin targets like 'action', 'group', etc).
  #   java_files: List of .java files to include in the apk.
  #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
  #      will be added to java_files and be included in this apk.
  #   apk_name: Name for final apk.
  #   final_apk_path: Path to final built apk. Default is
  #     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
  #   shared_libraries: List shared_library targets to bundle. If these
  #     libraries depend on other shared_library targets, those dependencies will
  #     also be included in the apk (e.g. for is_component_build).
  #   apk_under_test: The apk being tested.
  #   javac_args: Additional arguments to pass to javac.
  #
  # Example
  #   instrumentation_test_apk("foo_test_apk") {
  #     android_manifest = "AndroidManifest.xml"
  #     apk_name = "FooTest"
  #     apk_under_test = "Foo"
  #     java_files = [
  #       "android/org/chromium/foo/FooTestCase.java",
  #       "android/org/chromium/foo/FooExampleTest.java",
  #     ]
  #     deps = [
  #       ":foo_test_support_java"
  #     ]
  #   }
  template("instrumentation_test_apk") {
    assert(defined(invoker.apk_name))
    testonly = true
    _apk_target_name = "${target_name}__apk"
    _test_runner_target_name = "${target_name}__test_runner_script"
    _dist_ijar_path =
        "$root_build_dir/test.lib.java/" + invoker.apk_name + ".jar"
    _incremental_test_runner_target_name =
        "${_test_runner_target_name}_incremental"
    _incremental_test_name = "${invoker.target_name}_incremental"
    if (incremental_apk_by_default) {
      _incremental_test_runner_target_name = _test_runner_target_name
      _incremental_test_name = invoker.target_name
    }

    if (!incremental_apk_by_default) {
      test_runner_script(_test_runner_target_name) {
        forward_variables_from(invoker,
                               [
                                 "additional_apks",
                                 "apk_under_test",
                                 "data",
                                 "data_deps",
                                 "deps",
                                 "ignore_all_data_deps",
                                 "proguard_enabled",
                                 "public_deps",
                               ])
        test_name = invoker.target_name
        test_type = "instrumentation"
        apk_target = ":$_apk_target_name"
        test_jar = _dist_ijar_path
      }
    }
    test_runner_script(_incremental_test_runner_target_name) {
      forward_variables_from(invoker,
                             [
                               "additional_apks",
                               "apk_under_test",
                               "data",
                               "data_deps",
                               "deps",
                               "ignore_all_data_deps",
                               "public_deps",
                             ])
      test_name = _incremental_test_name
      test_type = "instrumentation"
      apk_target = ":$_apk_target_name"
      test_jar = _dist_ijar_path
      incremental_install = true
    }

    android_apk(_apk_target_name) {
      deps = []
      data_deps = []
      forward_variables_from(invoker, "*")
      deps += [ "//testing/android/broker:broker_java" ]
      data_deps += [
        "//build/android/pylib/device/commands",
        "//tools/android/forwarder2",
        "//tools/android/md5sum",
      ]
      if (defined(invoker.apk_under_test)) {
        data_deps += [ invoker.apk_under_test ]
      }
      if (defined(invoker.additional_apks)) {
        data_deps += invoker.additional_apks
      }
      if (defined(invoker.apk_under_test)) {
        # Prevent a build_hooks_android_impl exising in both the test apks as
        # well as the apk_under_test.
        no_build_hooks = true
      }

      if (defined(invoker.proguard_enabled) && invoker.proguard_enabled) {
        # When ProGuard is on, we use ProGuard to combine the under test java
        # code and the test java code. This is to allow us to apply all ProGuard
        # optimizations that we ship with, but not have them break tests. The
        # apk under test will still have the same resources, assets, and
        # manifest, all of which are the ones used in the tests.
        if (!defined(invoker.proguard_configs)) {
          proguard_configs = []
        }
        proguard_configs += [ "//testing/android/proguard_for_test.flags" ]
        if (defined(final_apk_path)) {
          _final_apk_path = final_apk_path
        } else {
          _final_apk_path = "$root_build_dir/apks/${apk_name}.apk"
        }
        data = [
          "$_final_apk_path.mapping",
        ]
      }

      dist_ijar_path = _dist_ijar_path
      create_apk_script = false
    }

    group(target_name) {
      if (incremental_apk_by_default) {
        public_deps = [
          ":${target_name}_incremental",
        ]
      } else {
        public_deps = [
          ":$_apk_target_name",
          ":$_test_runner_target_name",

          # Required by test runner to enumerate test list.
          ":${_apk_target_name}_dist_ijar",
        ]
        if (defined(invoker.apk_under_test)) {
          public_deps += [ invoker.apk_under_test ]
        }
      }

      # Ensure unstripped libraries are included in runtime deps so that
      # symbolization can be done.
      deps = [
        ":${_apk_target_name}__runtime_deps",
        ":${_apk_target_name}__secondary_abi_runtime_deps",
      ]
      if (defined(invoker.apk_under_test)) {
        _under_test_label =
            get_label_info(invoker.apk_under_test, "label_no_toolchain")
        deps += [
          "${_under_test_label}__runtime_deps",
          "${_under_test_label}__secondary_abi_runtime_deps",
        ]
      }
    }

    group("${target_name}_incremental") {
      public_deps = [
        ":$_incremental_test_runner_target_name",
        ":${_apk_target_name}_dist_ijar",
        ":${_apk_target_name}_incremental",
      ]
      if (defined(invoker.apk_under_test)) {
        public_deps += [ "${invoker.apk_under_test}_incremental" ]
      }
    }
  }

  # Declare an Android gtest apk
  #
  # This target creates an Android apk for running gtest-based unittests.
  #
  # Variables
  #   deps: Specifies the dependencies of this target. These will be passed to
  #     the underlying android_apk invocation and should include the java and
  #     resource dependencies of the apk.
  #   shared_library: shared_library target that contains the unit tests.
  #   apk_name: The name of the produced apk. If unspecified, it uses the name
  #             of the shared_library target suffixed with "_apk"
  #   use_default_launcher: Whether the default activity (NativeUnitTestActivity)
  #     should be used for launching tests.
  #   use_native_activity: Test implements ANativeActivity_onCreate().
  #
  # Example
  #   unittest_apk("foo_unittests_apk") {
  #     deps = [ ":foo_java", ":foo_resources" ]
  #     shared_library = ":foo_unittests"
  #   }
  template("unittest_apk") {
    _use_native_activity =
        defined(invoker.use_native_activity) && invoker.use_native_activity
    _android_manifest = "$target_gen_dir/$target_name/AndroidManifest.xml"
    assert(invoker.shared_library != "")

    # This trivial assert is needed in case android_manifest is defined,
    # as otherwise _use_native_activity and _android_manifest would not be used.
    assert(_use_native_activity != "" && _android_manifest != "")

    if (!defined(invoker.android_manifest)) {
      jinja_template("${target_name}_manifest") {
        _native_library_name = get_label_info(invoker.shared_library, "name")
        input = "//testing/android/native_test/java/AndroidManifest.xml.jinja2"
        output = _android_manifest
        variables = [
          "is_component_build=${is_component_build}",
          "native_library_name=${_native_library_name}",
          "use_native_activity=${_use_native_activity}",
        ]
      }
    }

    android_apk(target_name) {
      data_deps = []
      forward_variables_from(invoker, "*")
      testonly = true
      create_apk_script = false

      assert(!defined(invoker.proguard_enabled) || !invoker.proguard_enabled ||
             invoker.proguard_configs != [])

      if (!defined(apk_name)) {
        apk_name = get_label_info(invoker.shared_library, "name")
      }

      if (!defined(android_manifest)) {
        android_manifest_dep = ":${target_name}_manifest"
        android_manifest = _android_manifest
      }

      final_apk_path = "$root_build_dir/${apk_name}_apk/${apk_name}-debug.apk"

      if (!defined(use_default_launcher) || use_default_launcher) {
        deps += [ "//testing/android/native_test:native_test_java" ]
      }
      shared_libraries = [ invoker.shared_library ]
      deps += [
        ":${target_name}__runtime_deps",
        ":${target_name}__secondary_abi_runtime_deps",
        "//base:base_java",
        "//testing/android/reporter:reporter_java",
      ]
      data_deps += [
        "//build/android/pylib/device/commands",
        "//tools/android/md5sum",
      ]
      if (host_os == "linux") {
        data_deps += [ "//tools/android/forwarder2" ]
      }
    }
  }

  # Generate .java files from .aidl files.
  #
  # This target will store the .java files in a srcjar and should be included in
  # an android_library or android_apk's srcjar_deps.
  #
  # Variables
  #   sources: Paths to .aidl files to compile.
  #   import_include: Path to directory containing .java files imported by the
  #     .aidl files.
  #   interface_file: Preprocessed aidl file to import.
  #
  # Example
  #   android_aidl("foo_aidl") {
  #     import_include = "java/src"
  #     sources = [
  #       "java/src/com/foo/bar/FooBarService.aidl",
  #       "java/src/com/foo/bar/FooBarServiceCallback.aidl",
  #     ]
  #   }
  template("android_aidl") {
    action(target_name) {
      set_sources_assignment_filter([])
      forward_variables_from(invoker, [ "testonly" ])

      script = "//build/android/gyp/aidl.py"
      sources = invoker.sources

      _srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
      _aidl_path = "${android_sdk_build_tools}/aidl"
      _framework_aidl = "$android_sdk/framework.aidl"
      _imports = [ _framework_aidl ]
      if (defined(invoker.interface_file)) {
        assert(invoker.interface_file != "")
        _imports += [ invoker.interface_file ]
      }

      inputs = [ _aidl_path ] + _imports

      depfile = "${target_gen_dir}/${target_name}.d"
      outputs = [
        _srcjar_path,
      ]
      _rebased_imports = rebase_path(_imports, root_build_dir)
      args = [
        "--depfile",
        rebase_path(depfile, root_build_dir),
        "--aidl-path",
        rebase_path(_aidl_path, root_build_dir),
        "--imports=$_rebased_imports",
        "--srcjar",
        rebase_path(_srcjar_path, root_build_dir),
      ]
      if (defined(invoker.import_include) && invoker.import_include != []) {
        # TODO(cjhopman): aidl supports creating a depfile. We should be able to
        # switch to constructing a depfile for the overall action from that
        # instead of having all the .java files in the include paths as inputs.
        _rebased_import_paths = []
        foreach(_import_path, invoker.import_include) {
          _rebased_import_path = []
          _rebased_import_path = [ rebase_path(_import_path, root_build_dir) ]
          _rebased_import_paths += _rebased_import_path
          _java_files_build_rel = []
          _java_files_build_rel =
              exec_script("//build/android/gyp/find.py",
                          [ "--pattern=*.java" ] + _rebased_import_path,
                          "list lines")
          inputs += rebase_path(_java_files_build_rel, ".", root_build_dir)
        }
        args += [ "--includes=$_rebased_import_paths" ]
      }
      args += rebase_path(sources, root_build_dir)
    }
  }

  # Compile a protocol buffer to java.
  #
  # This generates java files from protocol buffers and creates an Android library
  # containing the classes.
  #
  # Variables
  #   sources (required)
  #       Paths to .proto files to compile.
  #
  #   proto_path (required)
  #       Root directory of .proto files.
  #
  #   generate_nano (optional, default false)
  #       Whether to generate nano protos. If false, this will use the lite proto generator.
  #       Nano protos are deprecated, so please use lite new proto libraries.
  #
  # Example:
  #  proto_java_library("foo_proto_java") {
  #    proto_path = "src/foo"
  #    sources = [ "$proto_path/foo.proto" ]
  #  }
  template("proto_java_library") {
    set_sources_assignment_filter([])
    forward_variables_from(invoker, [ "testonly" ])
    _generate_nano =
        defined(invoker.generate_nano) && invoker.generate_nano == true

    if (_generate_nano) {
      # Use the legacy Android nano proto generator.
      _protoc_dep =
          "//third_party/android_protobuf:android_protoc($host_toolchain)"
      _protoc_out_dir = get_label_info(_protoc_dep, "root_out_dir")
      _protoc_bin = "$_protoc_out_dir/android_protoc"
      _proto_runtime = "//third_party/android_protobuf:protobuf_nano_javalib"
    } else {
      # Use the regular proto library to generate lite protos.
      _protoc_dep = "//third_party/protobuf:protoc($host_toolchain)"
      _protoc_out_dir = get_label_info(_protoc_dep, "root_out_dir")
      _protoc_bin = "$_protoc_out_dir/protoc"
      _proto_runtime = "//third_party/protobuf:protobuf_lite_javalib"
    }
    _proto_path = invoker.proto_path
    _template_name = target_name

    action("${_template_name}__protoc_java") {
      _srcjar_path = "$target_gen_dir/$target_name.srcjar"
      script = "//build/protoc_java.py"

      deps = [
        _protoc_dep,
      ]
      if (defined(invoker.deps)) {
        deps += invoker.deps
      }

      sources = invoker.sources
      depfile = "$target_gen_dir/$target_name.d"
      outputs = [
        _srcjar_path,
      ]
      args = [
               "--depfile",
               rebase_path(depfile, root_build_dir),
               "--protoc",
               rebase_path(_protoc_bin, root_build_dir),
               "--proto-path",
               rebase_path(_proto_path, root_build_dir),
               "--srcjar",
               rebase_path(_srcjar_path, root_build_dir),
             ] + rebase_path(sources, root_build_dir)
      if (_generate_nano) {
        args += [ "--nano" ]
      }
    }

    android_library(target_name) {
      chromium_code = false
      java_files = []
      srcjar_deps = [ ":${_template_name}__protoc_java" ]
      deps = [
        _proto_runtime,
      ]
    }
  }

  # Declare an Android library target for a prebuilt AAR.
  #
  # This target creates an Android library containing java code and Android
  # resources. For libraries without resources, it will not generate
  # corresponding android_resources targets.
  #
  # To avoid slowing down "gn gen", an associated .info file must be committed
  # along with the .aar file. In order to create this file, define the target
  # and then run once with the gn arg "update_android_aar_prebuilts = true".
  #
  # Variables
  #   aar_path: Path to the AAR.
  #   info_path: Path to the .aar.info file (generated via
  #       update_android_aar_prebuilts GN arg).
  #   proguard_configs: List of proguard configs to use in final apk step for
  #       any apk that depends on this library.
  #   ignore_aidl: Whether to ignore .aidl files found with the .aar.
  #   ignore_assets: Whether to ignore assets found in the .aar.
  #   ignore_native_libraries: Whether to ignore .so files found in the .aar.
  #   create_srcjar: If false, does not create an R.java file.
  #   TODO(jbudorick@): remove this arguments after crbug.com/522043 is fixed.
  #   requires_android: Whether this target can only be used for compiling
  #       Android related targets.
  #
  # Example
  #   android_aar_prebuilt("foo_java") {
  #     aar_path = "foo.aar"
  #   }
  template("android_aar_prebuilt") {
    _info_path = "$target_name.info"
    if (defined(invoker.info_path)) {
      _info_path = invoker.info_path
    }
    _output_path = "${target_gen_dir}/${target_name}"
    _unpack_target_name = "${target_name}__unpack_aar"
    _ignore_aidl = defined(invoker.ignore_aidl) && invoker.ignore_aidl
    _ignore_assets = defined(invoker.ignore_assets) && invoker.ignore_assets
    _ignore_native_libraries = defined(invoker.ignore_native_libraries) &&
                               invoker.ignore_native_libraries

    # Scan the AAR file and determine the resources and jar files.
    # Some libraries might not have resources; others might have two jars.
    if (update_android_aar_prebuilts) {
      print("Writing " + rebase_path(_info_path, "//"))
      exec_script("//build/android/gyp/aar.py",
                  [
                    "list",
                    rebase_path(invoker.aar_path, root_build_dir),
                    "--output",
                    rebase_path(_info_path, root_build_dir),
                  ])
    }

    # If "gn gen" is failing on the following line, you need to generate an
    # .info file for your new target by running:
    #   gn gen --args='target_os="android" update_android_aar_prebuilts=true' out/tmp
    #   rm -r out/tmp
    _scanned_files = read_file(_info_path, "scope")

    assert(_ignore_aidl || _scanned_files.aidl == [],
           "android_aar_prebuilt() aidl not yet supported." +
               " Implement or use ignore_aidl = true." +
               " http://crbug.com/644439")
    assert(_ignore_assets || _scanned_files.assets == [],
           "android_aar_prebuilt() assets not yet supported." +
               " Implement or use ignore_assets = true." +
               " http://crbug.com/643966")
    assert(_ignore_native_libraries || !_scanned_files.has_native_libraries,
           "android_aar_prebuilt() with .so files is not supported." +
               " Use ignore_native_libraries = true to silence this error.")
    assert(_scanned_files.has_classes_jar || _scanned_files.subjars == [])

    action(_unpack_target_name) {
      script = "//build/android/gyp/aar.py"  # Unzips the AAR
      args = [
        "extract",
        rebase_path(invoker.aar_path, root_build_dir),
        "--output-dir",
        rebase_path(_output_path, root_build_dir),
        "--assert-info-file",
        rebase_path(_info_path, root_build_dir),
      ]
      inputs = [
        invoker.aar_path,
      ]
      outputs = [
        "${_output_path}/AndroidManifest.xml",
      ]

      if (_scanned_files.has_r_text_file) {
        # Certain packages, in particular Play Services have no R.txt even
        # though its presence is mandated by AAR spec. Such packages cause
        # spurious rebuilds if this output is specified unconditionally.
        outputs += [ "${_output_path}/R.txt" ]
      }

      if (_scanned_files.resources != []) {
        outputs += get_path_info(
                rebase_path(_scanned_files.resources, "", _output_path),
                "abspath")
      }
      if (_scanned_files.has_classes_jar) {
        outputs += [ "${_output_path}/classes.jar" ]
      }
      outputs +=
          get_path_info(rebase_path(_scanned_files.subjars, "", _output_path),
                        "abspath")
      if (_scanned_files.has_proguard_flags) {
        outputs += [ "${_output_path}/proguard.txt" ]
      }
    }

    # Create the android_resources target for resources.
    if (_scanned_files.resources != [] || _scanned_files.has_r_text_file ||
        !_scanned_files.is_manifest_empty) {
      _res_target_name = "${target_name}__res"
      android_resources(_res_target_name) {
        forward_variables_from(invoker,
                               [
                                 "create_srcjar",
                                 "deps",
                                 "testonly",
                               ])
        if (!defined(deps)) {
          deps = []
        }
        deps += [ ":$_unpack_target_name" ]
        resource_dirs = []
        generated_resource_dirs = []
        if (_scanned_files.resources != []) {
          generated_resource_dirs += [ "${_output_path}/res" ]
        }
        generated_resource_files =
            rebase_path(_scanned_files.resources, "", _output_path)
        android_manifest_dep = ":$_unpack_target_name"
        android_manifest = "${_output_path}/AndroidManifest.xml"
        if (_scanned_files.has_r_text_file) {
          r_text_file = "${_output_path}/R.txt"
        }
        v14_skip = true
      }
    }

    # Create android_java_prebuilt target for extra jars within jars/.
    _subjar_targets = []
    foreach(_tuple, _scanned_files.subjar_tuples) {
      _current_target = "${target_name}__subjar_${_tuple[0]}"
      _subjar_targets += [ ":$_current_target" ]
      java_prebuilt(_current_target) {
        forward_variables_from(invoker,
                               [
                                 "jar_excluded_patterns",
                                 "jar_included_patterns",
                                 "requires_android",
                               ])
        deps = [
          ":$_unpack_target_name",
        ]
        if (!defined(requires_android)) {
          requires_android = true
        }
        supports_android = true
        jar_path = "$_output_path/${_tuple[1]}"
        _base_output_name = get_path_info(jar_path, "name")
        output_name = "${invoker.target_name}-$_base_output_name"
      }
    }

    # Create android_java_prebuilt target for classes.jar.
    if (_scanned_files.has_classes_jar) {
      _jar_target_name = "${target_name}__classes"
      java_prebuilt(_jar_target_name) {
        forward_variables_from(invoker,
                               [
                                 "deps",
                                 "input_jars_paths",
                                 "jar_excluded_patterns",
                                 "jar_included_patterns",
                                 "proguard_configs",
                                 "requires_android",
                                 "testonly",
                               ])
        if (!defined(deps)) {
          deps = []
        }
        deps += _subjar_targets + [ ":$_unpack_target_name" ]
        if (defined(_res_target_name)) {
          deps += [ ":$_res_target_name" ]
        }
        if (!defined(requires_android)) {
          requires_android = true
        }
        supports_android = true
        jar_path = "$_output_path/classes.jar"
        output_name = invoker.target_name

        if (_scanned_files.has_proguard_flags) {
          if (!defined(proguard_configs)) {
            proguard_configs = []
          }
          proguard_configs += [ "$_output_path/proguard.txt" ]
        }
      }
    }

    java_group(target_name) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      public_deps = [
        ":$_unpack_target_name",
      ]
      deps = []
      if (defined(_jar_target_name)) {
        deps += [ ":$_jar_target_name" ]

        # Although subjars are meant to be private, we add them as deps here
        # because in practice they seem to contain classes required to be in the
        # classpath.
        deps += _subjar_targets
      }
      if (defined(_res_target_name)) {
        deps += [ ":$_res_target_name" ]
      }
    }
  }
}

# Compatibility wrapper to toggle android_deps usage for a dependency.
#
# This target creates a wrapper for a dependency allowing it to be loaded
# either from //third_party/android_deps or from an existing //third_party
# (or other) target.
#
# Variables
#   fallback_target: Target to use when the android_deps repo is not enabled.
#   android_deps_target_name: Name of the target from the android_deps repo to
#     use when the repo is enabled. Is not set, the wrapper's target name will
#     be used instead.
#
# Example
#   prebuilt_wrapper("android_support_multidex_java") {
#     android_deps_target_name = "com_android_support_multidex_java"
#     fallback_target = "$android_support_library_package:$target_name"
#   }
template("prebuilt_wrapper") {
  if (defined(invoker.android_deps_target_name)) {
    _resolved_android_deps_target_name = invoker.android_deps_target_name
  } else {
    _resolved_android_deps_target_name = target_name
  }

  if (enable_android_deps_repository) {
    _resolved_target =
        "//third_party/android_deps:${_resolved_android_deps_target_name}"
    assert(invoker.fallback_target != "")  # Mark as used.
  } else {
    _resolved_target = "${invoker.fallback_target}"
    assert(_resolved_android_deps_target_name != "")  # Mark as used.
  }

  java_group(target_name) {
    forward_variables_from(invoker, [ "testonly" ])
    deps = [
      _resolved_target,
    ]
  }
}