build/config/android/rules.gni

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

import("//base/android/linker/config.gni")
import("//build/config/android/config.gni")
import("//build/config/android/internal_rules.gni")
import("//tools/grit/grit_rule.gni")
import("//tools/relocation_packer/config.gni")

assert(is_android)

# 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") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.sources))
  assert(defined(invoker.jni_package))
  jni_package = invoker.jni_package
  base_output_dir = "${target_gen_dir}/${target_name}"
  package_output_dir = "${base_output_dir}/${jni_package}"
  jni_output_dir = "${package_output_dir}/jni"

  jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h"

  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
    inputs = [ jni_generator_include ]
    outputs = [
      depfile,
      "${jni_output_dir}/{{source_name_part}}_jni.h"
    ]

    args = [
      "--depfile", rebase_path(depfile, root_build_dir),
      "--input_file={{source}}",
      "--optimize_generation=1",
      "--ptr_type=long",
      "--output_dir", rebase_path(jni_output_dir, root_build_dir),
      "--includes", rebase_path(jni_generator_include, "//"),
    ]
    if (defined(invoker.jni_generator_jarjar_file)) {
      args += [
        "--jarjar", rebase_path(jni_generator_jarjar_file, root_build_dir),
      ]
    }
  }

  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) {
    deps = [ ":$foreach_target_name" ]
    public_configs = [ ":jni_includes_${target_name}" ]

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

    if (defined(invoker.visibility)) { visibility = invoker.visibility }
  }
}


# 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") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.classes))
  assert(defined(invoker.jni_package))

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

  jni_package = invoker.jni_package
  base_output_dir = "${root_gen_dir}/${target_name}/${jni_package}"
  jni_output_dir = "${base_output_dir}/jni"

  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_list = []
    _classname_list = process_file_template(
        [class], "{{source_name_part}}")
    classname = _classname_list[0]
    jni_target_name = "${target_name}__jni_${classname}"
    jni_actions += [ ":$jni_target_name" ]
    action(jni_target_name) {
      depfile = "$target_gen_dir/$target_name.d"
      script = "//base/android/jni_generator/jni_generator.py"
      sources = [
        jni_generator_include,
        jar_file,
      ]
      outputs = [
        depfile,
        "${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,
        "--optimize_generation=1",
        "--ptr_type=long",
        "--output_dir", rebase_path(jni_output_dir, root_build_dir),
        "--includes", rebase_path(jni_generator_include, root_build_dir),
      ]
    }
  }

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

  group(target_name) {
    deps = jni_actions
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
    if (defined(invoker.public_deps)) {
      public_deps = invoker.public_deps
    }
    public_configs = [ ":jni_includes_${target_name}" ]
  }
}


# 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_name: 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_name = "org/chromium/base/library_loader"
#     include_path = "android/java/templates"
#   }
template("java_cpp_template") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.sources))
  package_name = invoker.package_name + ""

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

  action_foreach("${target_name}__apply_gcc") {
    script = "//build/android/gyp/gcc_preprocess.py"
    if (defined(invoker.inputs)) {
      inputs = invoker.inputs + []
    }
    depfile = "${target_gen_dir}/${target_name}_{{source_name_part}}.d"

    sources = invoker.sources

    gen_dir = "${target_gen_dir}/${target_name}/java_cpp_template/${package_name}"
    gcc_template_output_pattern = "${gen_dir}/{{source_name_part}}.java"

    outputs = [
      depfile,
      gcc_template_output_pattern
    ]

    args = [
      "--depfile", rebase_path(depfile, root_build_dir),
      "--include-path", rebase_path(include_path, root_build_dir),
      "--output", rebase_path(gen_dir, root_build_dir) + "/{{source_name_part}}.java",
      "--template={{source}}",
    ]

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

  apply_gcc_outputs = get_target_outputs(":${target_name}__apply_gcc")
  base_gen_dir = get_label_info(":${target_name}__apply_gcc", "target_gen_dir")

  srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
  zip("${target_name}__zip_srcjar") {
    inputs = apply_gcc_outputs
    output = srcjar_path
    base_dir = base_gen_dir
  }

  group(target_name) {
    deps = [
      ":${target_name}__zip_srcjar"
    ]
  }
}

# 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.
#
#   outputs: list of outputs, relative to the output_dir. These paths are
#     verified at build time by the script. To get the list programatically run:
#       python build/android/gyp/java_cpp_enum.py --output_dir=. \
#         --print_output_only path/to/header/file.h
#
# Example
#   java_cpp_enum("foo_generated_enum") {
#     sources = [
#       "src/native_foo_header.h",
#     ]
#     outputs = [
#       "org/chromium/FooEnum.java",
#     ]
#   }
template("java_cpp_enum") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.sources))
  assert(defined(invoker.outputs))

  action("${target_name}__generate_enum") {
    sources = invoker.sources
    script = "//build/android/gyp/java_cpp_enum.py"
    gen_dir = "${target_gen_dir}/${target_name}/enums"
    outputs = get_path_info(
        rebase_path(invoker.outputs, ".", gen_dir), "abspath")

    args = [
      "--output_dir", rebase_path(gen_dir, root_build_dir),
    ]
    foreach(output, rebase_path(outputs, root_build_dir)) {
      args += ["--assert_file", output]
    }
    args += rebase_path(invoker.sources, root_build_dir)
  }

  generate_enum_outputs = get_target_outputs(":${target_name}__generate_enum")
  base_gen_dir = get_label_info(":${target_name}__generate_enum",
                                "target_gen_dir")

  srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
  zip("${target_name}__zip_srcjar") {
    inputs = generate_enum_outputs
    output = srcjar_path
    base_dir = base_gen_dir
  }

  group(target_name) {
    deps = [
      ":${target_name}__zip_srcjar"
    ]
  }
}

# Declare a target for processing a Jinja template.
#
# Variables
#   input: The template file to be processed.
#   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_shell_manifest") {
#     input = "shell/java/AndroidManifest.xml"
#     output = "$target_gen_dir/AndroidManifest.xml"
#   }
template("jinja_template") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.input))
  assert(defined(invoker.output))

  action(target_name) {
    sources = [invoker.input]
    script = "//build/android/gyp/jinja_template.py"
    depfile = "$target_gen_dir/$target_name.d"

    outputs = [
      depfile,
      invoker.output,
    ]

    args = [
      "--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.variables)) {
      variables = invoker.variables
      args += ["--variables=${variables}" ]
    }
  }
}

# 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_shell_template_resources") {
#     res_dir = "shell/res_template"
#     resources = ["shell/res_template/xml/syncable.xml"]
#     variables = ["color=red"]
#   }
template("jinja_template_resources") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.resources))
  assert(defined(invoker.res_dir))

  _base_path = "$target_gen_dir/$target_name"
  _resources_zip = _base_path + ".resources.zip"
  _build_config = _base_path + ".build_config"

  write_build_config("${target_name}__build_config") {
    build_config = _build_config
    resources_zip = _resources_zip
    type = "android_resources"
  }

  action("${target_name}__template") {
    sources = invoker.resources
    script = "//build/android/gyp/jinja_template.py"
    depfile = "$target_gen_dir/$target_name.d"

    outputs = [
      depfile,
      _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}" ]
    }
  }

  group(target_name) {
    deps = [
      ":${target_name}__build_config",
      ":${target_name}__template",
    ]
  }
}

# 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.
#   resource_dirs: List of directories containing resources for this target.
#   android_manifest: AndroidManifest.xml for this target. Defaults to
#     //build/android/AndroidManifest.xml.
#   custom_package: java package for generated .java files.
#   v14_verify_only: If true, don't generate v14/v17 resources and just verify
#     that the resources are v14-compliant (see
#     build/android/gyp/generate_v14_compatible_resources.py). Defaults to
#     false.
#
# Example
#   android_resources("foo_resources") {
#     deps = [":foo_strings_grd"]
#     resource_dirs = ["res"]
#     custom_package = "org.chromium.foo"
#   }
template("android_resources") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.resource_dirs))
  assert(defined(invoker.android_manifest) || defined(invoker.custom_package))

  base_path = "$target_gen_dir/$target_name"
  zip_path = base_path + ".resources.zip"
  srcjar_path = base_path + ".srcjar"
  build_config = base_path + ".build_config"

  write_build_config("${target_name}__build_config") {
    type = "android_resources"
    resources_zip = zip_path
    srcjar = srcjar_path
    if (defined(invoker.deps)) { deps = invoker.deps }
    if (defined(invoker.android_manifest)) { android_manifest = invoker.android_manifest }
    if (defined(invoker.custom_package)) { custom_package = invoker.custom_package }
  }

  android_manifest = "//build/android/AndroidManifest.xml"
  if (defined(invoker.android_manifest)) {
    android_manifest = invoker.android_manifest
  }

  process_resources("${target_name}__process_resources") {
    resource_dirs = invoker.resource_dirs
    if (defined(invoker.custom_package)) {
      custom_package = invoker.custom_package
    }

    if (defined(invoker.v14_verify_only)) {
      v14_verify_only = invoker.v14_verify_only
    }
  }

  group(target_name) {
    deps = [
      ":${target_name}__build_config",
      ":${target_name}__process_resources",
    ]
  }
}


# 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") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  base_path = "$target_gen_dir/$target_name"
  resources_zip = base_path + ".resources.zip"
  build_config = base_path + ".build_config"

  write_build_config("${target_name}__build_config") {
    type = "android_resources"
    if (defined(invoker.deps)) {
      deps = invoker.deps
    }
  }

  # Put grit files into this subdirectory of target_gen_dir.
  extra_output_path = target_name + "_grit_output"

  grit_target_name = "${target_name}__grit"
  grit_output_dir = "$target_gen_dir/$extra_output_path"
  grit(grit_target_name) {
    grit_flags = [
      "-E", "ANDROID_JAVA_TAGGED_ONLY=false",
    ]
    output_dir = grit_output_dir
    resource_ids = ""
    source = invoker.grd_file
    outputs = invoker.outputs
  }

  # This needs to get outputs from grit's internal target, not the final
  # source_set.
  generate_strings_outputs = get_target_outputs(":${grit_target_name}_grit")

  zip("${target_name}__zip") {
    base_dir = grit_output_dir
    inputs = generate_strings_outputs
    output = resources_zip
  }

  group(target_name) {
    deps = [
      ":${target_name}__build_config",
      ":${target_name}__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") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  base_path = "$target_gen_dir/$target_name"
  resources_zip = base_path + ".resources.zip"
  build_config = base_path + ".build_config"

  write_build_config("${target_name}__build_config") {
    type = "android_resources"
    if (defined(invoker.deps)) {
      deps = invoker.deps
    }
  }

  zip("${target_name}__zip") {
    base_dir = invoker.grit_output_dir
    inputs = rebase_path(invoker.generated_files, ".", base_dir)
    output = resources_zip
  }

  group(target_name) {
    deps = [
      ":${target_name}__build_config",
      ":${target_name}__zip",
    ]
  }
}


# Declare an Android library target
#
# This target creates an Android library containing java code and Android
# resources.
#
# Variables
#   deps: Specifies the dependencies of this target. Java targets in this list
#     will be added to the javac classpath. Android resources in dependencies
#     will be used when building this library.
#   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.
#   srcjars: List of srcjars to be included in this library, together with the
#     ones obtained from srcjar_deps.
#   chromium_code: If true, extra analysis warning/errors will be enabled.
#   jar_excluded_patterns: List of patterns of .class files to exclude from the
#     final jar.
#   proguard_preprocess: If true, proguard preprocessing will be run. This can
#     be used to remove unwanted parts of the library.
#   proguard_config: Path to the proguard config for preprocessing.
#
#   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
#     this directory will be included in the library. This is only supported to
#     ease the gyp->gn conversion and will be removed in the future.
#
# 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", "*/FooService##*.class"
#     ]
#   }
template("android_library") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir)
      || defined(invoker.srcjars) || defined(invoker.srcjar_deps))
  _base_path = "$target_gen_dir/$target_name"
  _build_config = _base_path + ".build_config"
  _jar_path = _base_path + ".jar"
  _dex_path = _base_path + ".dex.jar"

  write_build_config("${target_name}__build_config") {
    type = "android_library"

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

    build_config = _build_config
    jar_path = _jar_path
    dex_path = _dex_path
  }

  _chromium_code = true
  if (defined(invoker.chromium_code)) {
    _chromium_code = invoker.chromium_code
  }

  android_java_library(target_name) {
    chromium_code = _chromium_code
    if (defined(invoker.java_files)) {
      java_files = invoker.java_files
    } else if (defined(invoker.DEPRECATED_java_in_dir)) {
      DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
    }
    build_config = _build_config
    jar_path = _jar_path
    dex_path = _dex_path

    if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
      proguard_preprocess = true
      proguard_config = invoker.proguard_config
    }

    jar_excluded_patterns = [
      "*/R.class", "*/R##*.class",
      "*/Manifest.class", "*/Manifest##*.class",
    ]
    if (defined(invoker.jar_excluded_patterns)) {
      jar_excluded_patterns += invoker.jar_excluded_patterns
    }

    if (defined(invoker.srcjar_deps)) {
      srcjar_deps = invoker.srcjar_deps
    }
    if (defined(invoker.srcjars)) {
      srcjars = invoker.srcjars
    }
  }
}

template("java_library") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir)
      || defined(invoker.srcjars))

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

  _srcjars = []
  if (defined(invoker.srcjars)) {
    _srcjars = invoker.srcjars
  }

  _java_files = []
  if (defined(invoker.java_files)) {
    _java_files = invoker.java_files
  } else if (defined(invoker.DEPRECATED_java_in_dir)) {
    _src_dir = invoker.DEPRECATED_java_in_dir + "/src"
    _src_dir_exists = exec_script("//build/dir_exists.py",
          [ rebase_path(_src_dir, root_build_dir) ],
          "string")
    assert(_src_dir_exists == "False",
        "In GN, java_in_dir should be the fully specified java directory " +
        "(i.e. including the trailing \"/src\")")

    _java_files_build_rel = exec_script(
        "//build/android/gyp/find.py",
        [
          "--pattern",
          "*.java",
          rebase_path(invoker.DEPRECATED_java_in_dir, root_build_dir)
        ],
        "list lines"
        )
    _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
  }
  assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])

  # TODO(cjhopman): Write a proper build config so that java library
  # dependencies work correctly.
  _build_config = "$target_gen_dir/$target_name.build_config"
  write_file(
      _build_config,
      "{ \"javac\": { \"classpath\": [], \"srcjars\": [] } }")

  _jar_path = "$root_build_dir/lib.java/$target_name.jar"
  if (defined(invoker.jar_path)) {
    _jar_path = invoker.jar_path
  }

  compile_java(target_name) {
    build_config = _build_config
    jar_path = _jar_path
    java_files = _java_files
    srcjar_deps = _srcjar_deps
    srcjars = _srcjars
  }
}


# Declare an Android library target for a prebuilt jar
#
# This target creates an Android library containing java code and Android
# resources.
#
# Variables
#   deps: Specifies the dependencies of this target. Java targets in this list
#     will be added to the javac classpath. Android resources in dependencies
#     will be used when building this library.
#   jar_path: Path to the prebuilt jar.
#   proguard_preprocess: If true, proguard preprocessing will be run. This can
#     be used to remove unwanted parts of the library.
#   proguard_config: Path to the proguard config for preprocessing.
#
# Example
#   android_java_prebuilt("foo_java") {
#     jar_path = "foo.jar"
#     deps = [
#       ":foo_resources",
#       ":bar_java"
#     ]
#   }
template("android_java_prebuilt") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.jar_path))
  _base_path = "${target_gen_dir}/$target_name"
  _jar_path = _base_path + ".jar"
  _dex_path = _base_path + ".dex.jar"
  _build_config = _base_path + ".build_config"

  write_build_config("${target_name}__build_config") {
    type = "android_library"

    deps = []
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
    build_config = _build_config
    jar_path = _jar_path
    dex_path = _dex_path
  }

  java_prebuilt("${target_name}__process_jar") {
    if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
      proguard_preprocess = true
      proguard_config = invoker.proguard_config
    }

    build_config = _build_config
    input_jar_path = invoker.jar_path
    output_jar_path = _jar_path
  }

  dex("${target_name}__dex") {
    sources = [_jar_path]
    output = _dex_path
  }

  group(target_name) {
    deps = [
      ":${target_name}__build_config",
      ":${target_name}__dex",
    ]
  }
}



# Declare an Android apk target
#
# This target creates an Android APK containing java code, resources, assets,
# and (possibly) native libraries.
#
# Variables
#   android_manifest: Path to AndroidManifest.xml.
#   datadeps: 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.
#   native_libs: List paths of native libraries to include in this apk. If these
#     libraries depend on other shared_library targets, those dependencies will
#     also be included in the apk.
#   testonly: Marks this target as "test-only".
#
#   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
#     this directory will be included in the library. This is only supported to
#     ease the gyp->gn conversion and will be removed in the future.
#
# 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"
#     ]
#     native_libs = [
#       native_lib_path
#     ]
#   }
template("android_apk") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
  gen_dir = "$target_gen_dir/$target_name"
  base_path = "$gen_dir/$target_name"
  build_config = "$base_path.build_config"
  resources_zip_path = "$base_path.resources.zip"
  all_resources_zip_path = "$base_path.resources.all.zip"
  jar_path = "$base_path.jar"
  final_dex_path = "$gen_dir/classes.dex"
  _template_name = target_name
  _final_apk_path = ""
  if (defined(invoker.final_apk_path)) {
    _final_apk_path = invoker.final_apk_path
  } else if (defined(invoker.apk_name)) {
    _final_apk_path = "$root_build_dir/apks/" + invoker.apk_name + ".apk"
  }
  _dist_jar_path_list = process_file_template(
      [ _final_apk_path ],
      "$root_build_dir/test.lib.java/{{source_name_part}}.jar"
      )
  _dist_jar_path = _dist_jar_path_list[0]

  _native_libs = []

  _keystore_path = android_default_keystore_path
  _keystore_name = android_default_keystore_name
  _keystore_password = android_default_keystore_password

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

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

  _load_library_from_apk = false

  if (defined(invoker.native_libs)) {
    _use_chromium_linker = false
    if (defined(invoker.use_chromium_linker)) {
      _use_chromium_linker = (invoker.use_chromium_linker &&
        chromium_linker_supported)
    }

    if (defined(invoker.load_library_from_apk) &&
        invoker.load_library_from_apk) {
      _load_library_from_apk = true
      assert(_use_chromium_linker, "Loading library from the apk requires use" +
          " of the Chromium linker.")
    }

    _enable_relocation_packing = false
    if (defined(invoker.enable_relocation_packing) &&
        invoker.enable_relocation_packing) {
      _enable_relocation_packing = relocation_packing_supported
      assert(_use_chromium_linker, "Relocation packing requires use of the" +
          " Chromium linker.")
    }

    _native_libs = invoker.native_libs
    _native_libs_dir = base_path + "/libs"

    if (_use_chromium_linker) {
      _native_libs += [
        "$root_build_dir/lib.stripped/libchromium_android_linker.so"
      ]
    }

    _enable_relocation_packing = false
    if (_use_chromium_linker && defined(invoker.enable_relocation_packing) &&
        invoker.enable_relocation_packing) {
      _enable_relocation_packing = true
    }
  }

  _rebased_build_config = rebase_path(build_config, root_build_dir)

  write_build_config("${_template_name}__build_config") {
    type = "android_apk"
    dex_path = final_dex_path
    resources_zip = resources_zip_path

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

    native_libs = _native_libs
  }

  final_deps = []

  final_deps += [":${_template_name}__process_resources"]
  process_resources("${_template_name}__process_resources") {
    srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
    android_manifest = invoker.android_manifest
    resource_dirs = ["//build/android/ant/empty/res"]
    zip_path = resources_zip_path
    generate_constant_ids = true
  }
  _srcjar_deps += [":${_template_name}__process_resources"]

  if (_native_libs != []) {
    _enable_chromium_linker_tests = false
    if (defined(invoker.enable_chromium_linker_tests)) {
      _enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
    }

    _native_lib_version_name = ""

    java_cpp_template("${_template_name}__native_libraries_java") {
      package_name = "org/chromium/base/library_loader"
      sources = [
        "//base/android/java/templates/NativeLibraries.template",
      ]
      inputs = [
        build_config,
      ]

      defines = [
        "NATIVE_LIBRARIES_LIST=" +
          "@FileArg($_rebased_build_config:native:java_libraries_list)",
        "NATIVE_LIBRARIES_VERSION_NUMBER=\"$_native_lib_version_name\"",
      ]
      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" ]
  }

  final_deps += [ ":${_template_name}__java" ]
  android_java_library("${_template_name}__java") {
    android_manifest = invoker.android_manifest
    if (defined(invoker.java_files)) {
      java_files = invoker.java_files
    } else if (defined(invoker.DEPRECATED_java_in_dir)) {
      DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
    } else {
      java_files = []
    }
    srcjar_deps = _srcjar_deps
    dex_path = base_path + ".dex.jar"
  }

  if (_dist_jar_path != "") {
    # 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.
    action("${_template_name}__create_dist_jar") {
      script = "//build/android/gyp/create_dist_jar.py"
      depfile = "$target_gen_dir/$target_name.d"
      inputs = [ build_config ]
      outputs = [
        depfile,
        _dist_jar_path,
      ]
      args = [
        "--depfile", rebase_path(depfile, root_build_dir),
        "--output", rebase_path(_dist_jar_path, root_build_dir),
        "--inputs=@FileArg($_rebased_build_config:dist_jar:dependency_jars)",
      ]
      inputs += [ jar_path ]
      _rebased_jar_path = rebase_path([ jar_path ], root_build_dir)
      args += [
        "--inputs=$_rebased_jar_path",
      ]
    }
  }

  final_deps += [":${_template_name}__final_dex"]
  dex("${_template_name}__final_dex") {
    deps = [ ":${_template_name}__java" ]
    sources = [ jar_path ]
    inputs = [ build_config ]
    output = final_dex_path
    dex_arg_key = "${_rebased_build_config}:apk_dex:dependency_dex_files"
    args = [ "--inputs=@FileArg($dex_arg_key)" ]
  }

  if (_native_libs != []) {
    action("${_template_name}__prepare_native") {
      script = "//build/android/gyp/pack_arm_relocations.py"
      packed_libraries_dir = "$_native_libs_dir/$android_app_abi"
      depfile = "$target_gen_dir/$target_name.d"
      outputs = [
        depfile
      ]
      inputs = [
        build_config
      ]
      deps = []
      skip_packing_list = [
        "gdbserver",
        "libchromium_android_linker.so",
      ]

      enable_packing_arg = 0
      if (_enable_relocation_packing) {
        enable_packing_arg = 1
        deps += [
          relocation_packer_target
        ]
      }

      args = [
        "--depfile", rebase_path(depfile, root_build_dir),
        "--enable-packing=$enable_packing_arg",
        "--has-relocations-with-addends=$relocations_have_addends",
        "--exclude-packing-list=$skip_packing_list",
        "--android-pack-relocations", rebase_path(relocation_packer_exe, root_build_dir),
        "--android-objcopy", rebase_path(android_objcopy, root_build_dir),
        "--stripped-libraries-dir", rebase_path(root_build_dir, root_build_dir),
        "--packed-libraries-dir", rebase_path(packed_libraries_dir, root_build_dir),
        "--libraries=@FileArg(${_rebased_build_config}:native:libraries)",
        "--clear-dir"
      ]

      if (is_debug) {
        rebased_gdbserver = rebase_path([ android_gdbserver ], root_build_dir)
        inputs += [ android_gdbserver ]
        args += [
          "--libraries=$rebased_gdbserver"
        ]
      }
    }
  }

  final_deps += [":${_template_name}__create"]
  create_apk("${_template_name}__create") {
    apk_path = _final_apk_path
    android_manifest = invoker.android_manifest
    resources_zip = all_resources_zip_path
    dex_path = final_dex_path
    load_library_from_apk = _load_library_from_apk

    version_code = "1"
    if (defined(invoker.version_code)) {
      version_code = invoker.version_code
    }

    version_name = "Developer Build"
    if (defined(invoker.version_name)) {
      version_name = invoker.version_name
    }

    if (defined(invoker.asset_location)) {
      asset_location = invoker.asset_location
    }

    keystore_name = _keystore_name
    keystore_path = _keystore_path
    keystore_password = _keystore_password

    if (_native_libs != []) {
      native_libs_dir = _native_libs_dir
      deps = [":${_template_name}__prepare_native"]
    }
  }

  group(target_name) {
    deps = final_deps
    if (defined(invoker.datadeps)) {
      # TODO(cjhopman): Fix this when group datadeps works.
      deps += invoker.datadeps
    }
  }
}


# 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.
#   unittests_dep: This should be the label of the gtest native target. This
#     target must be defined previously in the same file.
#   unittests_binary: The name of the binary produced by the unittests_dep
#     target, relative to the root build directory. If unspecified, it assumes
#     the name of the unittests_dep target (which will be correct unless that
#     target specifies an "output_name".
#     TODO(brettw) make this automatic by allowing get_target_outputs to
#     support executables.
#
# Example
#   unittest_apk("foo_unittests_apk") {
#     deps = [ ":foo_java", ":foo_resources" ]
#     unittests_dep = ":foo_unittests"
#   }
template("unittest_apk") {
  testonly = true

  assert(defined(invoker.unittests_dep), "Need unittests_dep for $target_name")

  test_suite_name = get_label_info(invoker.unittests_dep, "name")

  if (defined(invoker.unittests_binary)) {
    unittests_binary = root_out_dir + "/" + invoker.unittests_binary
  } else {
    unittests_binary = root_out_dir + "/lib.stripped/lib" + test_suite_name + ".so"
  }

  android_apk(target_name) {
    _apk_name = test_suite_name
    final_apk_path = "$root_build_dir/${_apk_name}_apk/${_apk_name}-debug.apk"
    java_files = [
      "//testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java"
    ]
    android_manifest = "//testing/android/java/AndroidManifest.xml"
    unittests_outputs = [ unittests_binary ]
    native_libs = [unittests_outputs[0]]
    deps = [ "//base:base_java" ]
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
    datadeps = [
      "//tools/android/md5sum",
    ]
  }
}

# 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") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
  aidl_path = "${android_sdk_build_tools}/aidl"
  framework_aidl = "$android_sdk/framework.aidl"

  action(target_name) {
    script = "//build/android/gyp/aidl.py"
    sources = invoker.sources

    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 = [
      depfile,
      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_includes = rebase_path(
          [invoker.import_include], root_build_dir)
      args += [ "--includes=$rebased_import_includes" ]

      _java_files_build_rel = exec_script(
          "//build/android/gyp/find.py",
          rebase_path([invoker.import_include], root_build_dir),
          "list lines"
          )
      _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
      inputs += _java_files
    }
    args += rebase_path(sources, root_build_dir)
  }
}

# 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.
#
# Example
#   create_native_executable_dist("foo_dist") {
#     dist_dir = "$root_build_dir/foo_dist"
#     binary = "$root_build_dir/exe.stripped/foo"
#   }
template("create_native_executable_dist") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }

  dist_dir = invoker.dist_dir
  binary = invoker.binary
  final_deps = []
  template_name = target_name

  libraries_list = "${target_gen_dir}/${template_name}_library_dependencies.list"

  # TODO(gyp)
  #'dependencies': [
  #'<(DEPTH)/build/android/setup.gyp:copy_system_libraries',
  #],

  stripped_libraries_dir = "$root_build_dir/lib.stripped"
  final_deps += [ ":${template_name}__find_library_dependencies" ]
  action("${template_name}__find_library_dependencies") {
    script = "//build/android/gyp/write_ordered_libraries.py"
    depfile = "$target_gen_dir/$target_name.d"
    inputs = [
      binary,
      android_readelf,
    ]
    outputs = [
      depfile,
      libraries_list,
    ]
    rebased_binaries = rebase_path([ binary ], root_build_dir)
    args = [
      "--depfile", rebase_path(depfile, root_build_dir),
      "--input-libraries=$rebased_binaries",
      "--libraries-dir", rebase_path(stripped_libraries_dir, root_build_dir),
      "--output", rebase_path(libraries_list, root_build_dir),
      "--readelf", rebase_path(android_readelf, root_build_dir),
    ]
  }

  final_deps += [ ":${template_name}__copy_libraries_and_exe" ]
  copy_ex("${template_name}__copy_libraries_and_exe") {
    clear_dir = true
    inputs = [
      binary,
      libraries_list
    ]
    dest = dist_dir
    rebased_binaries_list = rebase_path([ binary ], root_build_dir)
    rebased_libraries_list = rebase_path(libraries_list, root_build_dir)
    args = [
      "--files=$rebased_binaries_list",
      "--files=@FileArg($rebased_libraries_list:libraries)",
    ]
  }

  group(target_name) {
    deps = final_deps
  }
}


# Compile a protocol buffer to java.
#
# This generates java files from protocol buffers and creates an Android library
# containing the classes.
#
# Variables
#   sources: Paths to .proto files to compile.
#   proto_path: Root directory of .proto files.
#
# Example:
#  proto_java_library("foo_proto_java") {
#    proto_path = [ "src/foo" ]
#    sources = [ "$proto_path/foo.proto" ]
#  }
template("proto_java_library") {
  _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_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
    ]
    sources = invoker.sources
    depfile = "$target_gen_dir/$target_name.d"
    outputs = [
      depfile,
      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)
  }

  android_library(target_name) {
    java_files = []
    srcjar_deps = [ ":${_template_name}__protoc_java" ]
    deps = [
      "//third_party/android_protobuf:protobuf_nano_javalib",
    ]
  }
}

# TODO(GYP): implement this.
template("uiautomator_test") {
  if (defined(invoker.testonly)) { testonly = invoker.testonly }
  assert(target_name != "")
  assert(invoker.deps != [] || true)
  group(target_name) {
  }
}