mirror/naiveproxy
1
0
Fork 0
mirror of https://github.com/klzgrad/naiveproxy.git synced 2024-11-24 14:26:09 +03:00
Code Issues Projects Releases Wiki Activity
2096042f1c
naiveproxy/build/config/android/internal_rules.gni
klzgrad e45b4af2be Import chromium-68.0.3440.106
2018-08-11 05:35:24 +00:00

3151 lines
111 KiB
Plaintext
Raw Blame History

# 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_overrides/build.gni")
import("//build/config/android/config.gni")
import("//build/config/dcheck_always_on.gni")
import("//build/config/sanitizers/sanitizers.gni")
assert(is_android)
# These identify targets that have .build_config files (except for android_apk,
# java_binary, resource_rewriter, since we never need to depend on these).
_java_target_whitelist = [
"*:*_java",
"*:*_javalib",
"*:*_java_*", # e.g. java_test_support
"*:java",
"*:junit",
"*:junit_*",
"*:*_junit_*",
"*:*javatests",
"*:*_assets",
"*android*:assets",
"*:*_apk_*resources",
"*android*:resources",
"*:*_resources",
"*:*_grd",
"*:*locale_paks",
# TODO(agrieve): Rename targets below to match above patterns.
"*android_webview/glue:glue",
]
# Targets that match the whitelist but are not actually java targets.
_java_target_blacklist = [
"//chrome:packed_resources",
"*:*_unpack_aar",
]
_default_proguard_jar_path = "//third_party/proguard/lib/proguard.jar"
# Write the target's .build_config file. This is a json file that contains a
# dictionary of information about how to build this target (things that
# require knowledge about this target's dependencies and cannot be calculated
# at gn-time). There is a special syntax to add a value in that dictionary to
# an action/action_foreachs args:
# --python-arg=@FileArg($rebased_build_config_path:key0:key1)
# At runtime, such an arg will be replaced by the value in the build_config.
# See build/android/gyp/write_build_config.py and
# build/android/gyp/util/build_utils.py:ExpandFileArgs
template("write_build_config") {
_type = invoker.type
# Don't need to enforce naming scheme for these targets since we never
# consider them in dependency chains.
if (_type != "android_apk" && _type != "java_binary" &&
_type != "resource_rewriter" && _type != "dist_jar" &&
_type != "java_annotation_processor" && _type != "dist_aar") {
set_sources_assignment_filter(_java_target_whitelist)
_parent_invoker = invoker.invoker
_target_label =
get_label_info(":${_parent_invoker.target_name}", "label_no_toolchain")
sources = [
_target_label,
]
if (sources != []) {
set_sources_assignment_filter(_java_target_blacklist)
sources = []
sources = [
_target_label,
]
if (sources != []) {
assert(false, "Invalid java target name: $_target_label")
}
}
sources = []
}
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"testonly",
])
if (!defined(deps)) {
deps = []
}
if (defined(invoker.android_manifest_dep)) {
deps += [ invoker.android_manifest_dep ]
}
script = "//build/android/gyp/write_build_config.py"
depfile = "$target_gen_dir/$target_name.d"
inputs = []
outputs = [
invoker.build_config,
]
_deps_configs = []
if (defined(invoker.possible_config_deps)) {
foreach(_possible_dep, invoker.possible_config_deps) {
set_sources_assignment_filter(_java_target_whitelist)
_target_label = get_label_info(_possible_dep, "label_no_toolchain")
sources = [
_target_label,
]
if (sources == []) {
set_sources_assignment_filter(_java_target_blacklist)
sources = []
sources = [
_target_label,
]
if (sources != []) {
deps += [ "${_target_label}__build_config" ]
_dep_gen_dir = get_label_info(_possible_dep, "target_gen_dir")
_dep_name = get_label_info(_possible_dep, "name")
_deps_configs += [ "$_dep_gen_dir/$_dep_name.build_config" ]
}
}
sources = []
}
}
_rebased_deps_configs = rebase_path(_deps_configs, root_build_dir)
args = [
"--type=$_type",
"--depfile",
rebase_path(depfile, root_build_dir),
"--deps-configs=$_rebased_deps_configs",
"--build-config",
rebase_path(invoker.build_config, root_build_dir),
]
if (defined(invoker.jar_path)) {
args += [
"--jar-path",
rebase_path(invoker.jar_path, root_build_dir),
]
}
if (defined(invoker.unprocessed_jar_path)) {
args += [
"--unprocessed-jar-path",
rebase_path(invoker.unprocessed_jar_path, root_build_dir),
]
}
if (defined(invoker.ijar_path)) {
args += [
"--interface-jar-path",
rebase_path(invoker.ijar_path, root_build_dir),
]
}
if (defined(invoker.java_resources_jar)) {
args += [
"--java-resources-jar-path",
rebase_path(invoker.java_resources_jar, root_build_dir),
]
}
if (defined(invoker.annotation_processor_deps)) {
_processor_configs = []
foreach(_processor_dep, invoker.annotation_processor_deps) {
_target_label = get_label_info(_processor_dep, "label_no_toolchain")
_dep_gen_dir = get_label_info(_processor_dep, "target_gen_dir")
_dep_name = get_label_info(_processor_dep, "name")
deps += [ "${_target_label}__build_config" ]
_processor_configs += [ "$_dep_gen_dir/$_dep_name.build_config" ]
}
_rebased_processor_configs =
rebase_path(_processor_configs, root_build_dir)
args += [ "--annotation-processor-configs=$_rebased_processor_configs" ]
}
if (defined(invoker.dex_path)) {
args += [
"--dex-path",
rebase_path(invoker.dex_path, root_build_dir),
]
}
if (defined(invoker.supports_android) && invoker.supports_android) {
args += [ "--supports-android" ]
}
if (defined(invoker.requires_android) && invoker.requires_android) {
args += [ "--requires-android" ]
}
if (defined(invoker.is_prebuilt) && invoker.is_prebuilt) {
args += [ "--is-prebuilt" ]
}
if (defined(invoker.bypass_platform_checks) &&
invoker.bypass_platform_checks) {
args += [ "--bypass-platform-checks" ]
}
if (defined(invoker.apk_under_test)) {
deps += [ "${invoker.apk_under_test}__build_config" ]
apk_under_test_gen_dir =
get_label_info(invoker.apk_under_test, "target_gen_dir")
apk_under_test_name = get_label_info(invoker.apk_under_test, "name")
apk_under_test_config =
"$apk_under_test_gen_dir/$apk_under_test_name.build_config"
args += [
"--tested-apk-config",
rebase_path(apk_under_test_config, root_build_dir),
]
}
if (defined(invoker.asset_sources)) {
_rebased_asset_sources =
rebase_path(invoker.asset_sources, root_build_dir)
args += [ "--asset-sources=$_rebased_asset_sources" ]
}
if (defined(invoker.asset_renaming_sources)) {
_rebased_asset_renaming_sources =
rebase_path(invoker.asset_renaming_sources, root_build_dir)
args += [ "--asset-renaming-sources=$_rebased_asset_renaming_sources" ]
# These are zip paths, so no need to rebase.
args += [
"--asset-renaming-destinations=${invoker.asset_renaming_destinations}",
]
}
if (defined(invoker.disable_compression) && invoker.disable_compression) {
args += [ "--disable-asset-compression" ]
}
if (defined(invoker.treat_as_locale_paks) && invoker.treat_as_locale_paks) {
args += [ "--treat-as-locale-paks" ]
}
if (defined(invoker.android_manifest)) {
inputs += [ invoker.android_manifest ]
args += [
"--android-manifest",
rebase_path(invoker.android_manifest, root_build_dir),
]
}
if (defined(invoker.resources_zip)) {
args += [
"--resources-zip",
rebase_path(invoker.resources_zip, root_build_dir),
]
}
if (defined(invoker.custom_package)) {
args += [
"--package-name",
invoker.custom_package,
]
}
if (defined(invoker.r_text)) {
args += [
"--r-text",
rebase_path(invoker.r_text, root_build_dir),
]
}
if (defined(invoker.resource_dirs)) {
resource_dirs = rebase_path(invoker.resource_dirs, root_build_dir)
args += [ "--resource-dirs=$resource_dirs" ]
}
if (defined(invoker.proto_resources_path)) {
_rebased_proto_resources =
rebase_path(invoker.proto_resources_path, root_build_dir)
args += [ "--apk-proto-resources=$_rebased_proto_resources" ]
}
if (defined(invoker.shared_libraries_runtime_deps_file)) {
# Don't list shared_libraries_runtime_deps_file as an input in order to
# avoid having to depend on the runtime_deps target. See comment in
# rules.gni for why we do this.
args += [
"--shared-libraries-runtime-deps",
rebase_path(invoker.shared_libraries_runtime_deps_file, root_build_dir),
]
}
if (defined(invoker.extra_shared_libraries)) {
_rebased_extra_shared_libraries =
rebase_path(invoker.extra_shared_libraries, root_build_dir)
args += [ "--extra-shared-libraries=$_rebased_extra_shared_libraries" ]
}
if (defined(invoker.secondary_abi_shared_libraries_runtime_deps_file)) {
# Don't list secondary_abi_shared_libraries_runtime_deps_file as an
# input in order to avoid having to depend on the runtime_deps target.
# See comment in rules.gni for why we do this.
args += [
"--secondary-abi-shared-libraries-runtime-deps",
rebase_path(invoker.secondary_abi_shared_libraries_runtime_deps_file,
root_build_dir),
]
}
if (defined(invoker.uncompress_shared_libraries) &&
invoker.uncompress_shared_libraries) {
args += [ "--uncompress-shared-libraries" ]
}
if (defined(invoker.apk_path)) {
_rebased_apk_path = rebase_path(invoker.apk_path, root_build_dir)
_rebased_incremental_apk_path =
rebase_path(invoker.incremental_apk_path, root_build_dir)
_rebased_incremental_install_json_path =
rebase_path(invoker.incremental_install_json_path, root_build_dir)
_incremental_allowed =
defined(invoker.incremental_allowed) && invoker.incremental_allowed
args += [ "--apk-path=$_rebased_apk_path" ]
args += [ "--incremental-install-json-path=$_rebased_incremental_install_json_path" ]
assert(_rebased_incremental_apk_path != "") # Mark as used.
if (_incremental_allowed) {
args += [ "--incremental-apk-path=$_rebased_incremental_apk_path" ]
}
}
if (defined(invoker.non_native_packed_relocations) &&
invoker.non_native_packed_relocations) {
args += [ "--non-native-packed-relocations" ]
}
if (defined(invoker.java_sources_file)) {
args += [
"--java-sources-file",
rebase_path(invoker.java_sources_file, root_build_dir),
]
}
if (defined(invoker.srcjar)) {
args += [
"--srcjar",
rebase_path(invoker.srcjar, root_build_dir),
]
}
if (defined(invoker.bundled_srcjars)) {
_rebased_bundled_srcjars =
rebase_path(invoker.bundled_srcjars, root_build_dir)
args += [ "--bundled-srcjars=$_rebased_bundled_srcjars" ]
}
if (defined(invoker.classpath_deps)) {
_classpath_deps_configs = []
foreach(d, invoker.classpath_deps) {
_target_label = get_label_info(d, "label_no_toolchain")
deps += [ "${_target_label}__build_config" ]
_dep_gen_dir = get_label_info(d, "target_gen_dir")
_dep_name = get_label_info(d, "name")
_classpath_deps_configs += [ "$_dep_gen_dir/$_dep_name.build_config" ]
}
_rebased_classpath_deps_configs =
rebase_path(_classpath_deps_configs, root_build_dir)
args += [ "--classpath-deps-configs=$_rebased_classpath_deps_configs" ]
}
if (defined(invoker.input_jars_paths)) {
_rebased_input_jars_paths =
rebase_path(invoker.input_jars_paths, root_build_dir)
args += [ "--extra-classpath-jars=$_rebased_input_jars_paths" ]
}
if (defined(invoker.proguard_enabled) && invoker.proguard_enabled) {
args += [ "--proguard-enabled" ]
}
if (defined(invoker.proguard_configs)) {
_rebased_proguard_configs =
rebase_path(invoker.proguard_configs, root_build_dir)
args += [ "--proguard-configs=$_rebased_proguard_configs" ]
}
if (defined(invoker.gradle_treat_as_prebuilt) &&
invoker.gradle_treat_as_prebuilt) {
args += [ "--gradle-treat-as-prebuilt" ]
}
if (defined(invoker.main_class)) {
args += [
"--main-class",
invoker.main_class,
]
}
if (current_toolchain != default_toolchain) {
# This has to be a built-time error rather than a GN assert because many
# packages have a mix of java and non-java targets. For example, the
# following would fail even though nothing depends on :bar(//baz):
#
# shared_library("foo") {
# }
#
# android_library("bar") {
# deps = [ ":foo(//baz)" ]
# assert(current_toolchain == default_toolchain)
# }
_msg = [
"Tried to build an Android target in a non-default toolchain.",
"target: " + get_label_info(":$target_name", "label_with_toolchain"),
"default_toolchain: $default_toolchain",
]
args += [ "--fail=$_msg" ]
}
}
}
# Copy a list of file into a destination directory. Potentially renaming
# files are they are copied. This also ensures that symlinks are followed
# during the copy (i.e. the symlinks are never copied, only their content).
#
# Variables:
# dest: Destination directory path.
# sources: List of source files or directories to copy to dest.
# renaming_sources: Optional list of source file paths that will be renamed
# during the copy operation. If provided, renaming_destinations is required.
# renaming_destinations: Optional list of destination file paths, required
# when renaming_sources is provided. Both lists should have the same size
# and matching entries.
# args: Optional. Additionnal arguments to the copy_ex.py script.
#
# The following variables have the usual GN meaning: data, deps, inputs,
# outputs, testonly, visibility.
#
template("copy_ex") {
set_sources_assignment_filter([])
action(target_name) {
forward_variables_from(invoker,
[
"data",
"deps",
"inputs",
"outputs",
"sources",
"testonly",
"visibility",
])
if (!defined(sources)) {
sources = []
}
script = "//build/android/gyp/copy_ex.py"
args = [
"--dest",
rebase_path(invoker.dest, root_build_dir),
]
rebased_sources = rebase_path(sources, root_build_dir)
args += [ "--files=$rebased_sources" ]
if (defined(invoker.args)) {
args += invoker.args
}
if (defined(invoker.renaming_sources) &&
defined(invoker.renaming_destinations)) {
sources += invoker.renaming_sources
rebased_renaming_sources =
rebase_path(invoker.renaming_sources, root_build_dir)
args += [ "--renaming-sources=$rebased_renaming_sources" ]
renaming_destinations = invoker.renaming_destinations
args += [ "--renaming-destinations=$renaming_destinations" ]
}
}
}
# Generates a script in the build bin directory which runs the test
# target using the test runner script in build/android/test_runner.py.
template("test_runner_script") {
testonly = true
_test_name = invoker.test_name
_test_type = invoker.test_type
_incremental_install =
defined(invoker.incremental_install) && invoker.incremental_install
_runtime_deps =
!defined(invoker.ignore_all_data_deps) || !invoker.ignore_all_data_deps
if (_runtime_deps) {
# This runtime_deps file is used at runtime and thus cannot go in
# target_gen_dir.
_target_dir_name = get_label_info(":$target_name", "dir")
_runtime_deps_file =
"$root_out_dir/gen.runtime/$_target_dir_name/$target_name.runtime_deps"
_runtime_deps_target = "${target_name}__write_deps"
group(_runtime_deps_target) {
forward_variables_from(invoker,
[
"data",
"deps",
"public_deps",
])
data_deps = []
if (defined(invoker.data_deps)) {
data_deps += invoker.data_deps
}
if (defined(invoker.additional_apks)) {
data_deps += invoker.additional_apks
}
write_runtime_deps = _runtime_deps_file
}
}
action(target_name) {
forward_variables_from(invoker,
[
"data_deps",
"deps",
])
if (!defined(deps)) {
deps = []
}
if (!defined(data_deps)) {
data_deps = []
}
script = "//build/android/gyp/create_test_runner_script.py"
depfile = "$target_gen_dir/$target_name.d"
data_deps += [
"//build/android:test_runner_py",
"//build/android:logdog_wrapper_py",
]
data = []
test_runner_args = [
_test_type,
"--output-directory",
rebase_path(root_build_dir, root_build_dir),
]
if (_runtime_deps) {
deps += [ ":$_runtime_deps_target" ]
data += [ _runtime_deps_file ]
test_runner_args += [
"--runtime-deps-path",
rebase_path(_runtime_deps_file, root_build_dir),
]
}
# apk_target is not used for native executable tests
# (e.g. breakpad_unittests).
if (defined(invoker.apk_target)) {
assert(!defined(invoker.executable_dist_dir))
deps += [ "${invoker.apk_target}__build_config" ]
_apk_build_config =
get_label_info(invoker.apk_target, "target_gen_dir") + "/" +
get_label_info(invoker.apk_target, "name") + ".build_config"
_rebased_apk_build_config = rebase_path(_apk_build_config, root_build_dir)
assert(_rebased_apk_build_config != "") # Mark as used.
} else if (_test_type == "gtest") {
assert(
defined(invoker.executable_dist_dir),
"Must define either apk_target or executable_dist_dir for test_runner_script()")
test_runner_args += [
"--executable-dist-dir",
rebase_path(invoker.executable_dist_dir, root_build_dir),
]
}
_device_test = true
if (_test_type == "gtest") {
assert(defined(invoker.test_suite))
test_runner_args += [
"--suite",
invoker.test_suite,
]
} else if (_test_type == "instrumentation") {
_test_apk = "@FileArg($_rebased_apk_build_config:deps_info:apk_path)"
if (_incremental_install) {
_test_apk = "@FileArg($_rebased_apk_build_config:deps_info:incremental_apk_path)"
}
test_runner_args += [
"--test-apk=$_test_apk",
"--test-jar",
rebase_path(invoker.test_jar, root_build_dir),
]
if (defined(invoker.apk_under_test)) {
deps += [ "${invoker.apk_under_test}__build_config" ]
_apk_under_test_build_config =
get_label_info(invoker.apk_under_test, "target_gen_dir") + "/" +
get_label_info(invoker.apk_under_test, "name") + ".build_config"
_rebased_apk_under_test_build_config =
rebase_path(_apk_under_test_build_config, root_build_dir)
_apk_under_test =
"@FileArg($_rebased_apk_under_test_build_config:deps_info:apk_path)"
if (_incremental_install) {
_apk_under_test = "@FileArg($_rebased_apk_under_test_build_config:deps_info:incremental_apk_path)"
}
test_runner_args += [ "--apk-under-test=$_apk_under_test" ]
test_runner_args += [
"--non-native-packed-relocations",
"@FileArg($_rebased_apk_under_test_build_config:deps_info:non_native_packed_relocations)",
]
}
if (defined(invoker.proguard_enabled) && invoker.proguard_enabled) {
test_runner_args += [ "--enable-java-deobfuscation" ]
}
if (emma_coverage) {
# Set a default coverage output directory (can be overridden by user
# passing the same flag).
test_runner_args += [
"--coverage-dir",
rebase_path("$root_out_dir/coverage", root_build_dir),
]
}
} else if (_test_type == "junit") {
assert(defined(invoker.test_suite))
_device_test = false
test_runner_args += [
"--test-suite",
invoker.test_suite,
]
if (defined(invoker.android_manifest_path)) {
test_runner_args += [
"--android-manifest-path",
rebase_path(invoker.android_manifest_path, root_build_dir),
]
}
if (defined(invoker.package_name)) {
test_runner_args += [
"--package-name",
invoker.package_name,
]
deps += [ ":${invoker.test_suite}__build_config" ]
_junit_binary_build_config =
"${target_gen_dir}/${invoker.test_suite}.build_config"
_rebased_build_config =
rebase_path("$_junit_binary_build_config", root_build_dir)
test_runner_args += [
"--resource-zips",
"@FileArg($_rebased_build_config:resources:dependency_zips)",
]
}
test_runner_args += [
"--robolectric-runtime-deps-dir",
rebase_path("$root_build_dir/lib.java/third_party/robolectric",
root_build_dir),
]
} else if (_test_type == "linker") {
test_runner_args += [
"--test-apk",
"@FileArg($_rebased_apk_build_config:deps_info:apk_path)",
]
} else {
assert(false, "Invalid test type: $_test_type.")
}
if (defined(invoker.additional_apks)) {
foreach(additional_apk, invoker.additional_apks) {
deps += [ "${additional_apk}__build_config" ]
_build_config = get_label_info(additional_apk, "target_gen_dir") + "/" +
get_label_info(additional_apk, "name") + ".build_config"
_rebased_build_config = rebase_path(_build_config, root_build_dir)
test_runner_args += [
"--additional-apk",
"@FileArg($_rebased_build_config:deps_info:apk_path)",
"--additional-apk-incremental",
"@FileArg($_rebased_build_config:deps_info:incremental_apk_path)",
]
}
}
if (defined(invoker.shard_timeout)) {
test_runner_args += [ "--shard-timeout=${invoker.shard_timeout}" ]
}
if (_incremental_install) {
test_runner_args += [
"--test-apk-incremental-install-json",
"@FileArg($_rebased_apk_build_config:deps_info:incremental_install_json_path)",
]
if (defined(invoker.apk_under_test)) {
test_runner_args += [
"--apk-under-test-incremental-install-json",
"@FileArg($_rebased_apk_under_test_build_config:deps_info:incremental_install_json_path)",
]
}
test_runner_args += [ "--fast-local-dev" ]
}
if (_device_test && is_asan) {
test_runner_args += [ "--tool=asan" ]
}
if (defined(invoker.generated_script)) {
assert(_test_name != "" || true) # Mark _test_name as used.
generated_script = invoker.generated_script
} else {
generated_script = "$root_build_dir/bin/run_${_test_name}"
}
outputs = [
generated_script,
]
data += [ generated_script ]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--script-output-path",
rebase_path(generated_script, root_build_dir),
]
if (defined(android_test_runner_script)) {
args += [
"--test-runner-path",
android_test_runner_script,
]
}
args += test_runner_args
}
}
template("stack_script") {
forward_variables_from(invoker, [ "testonly" ])
_stack_target_name = invoker.stack_target_name
action(target_name) {
forward_variables_from(invoker,
[
"data_deps",
"deps",
])
if (!defined(deps)) {
deps = []
}
if (!defined(data_deps)) {
data_deps = []
}
data_deps +=
[ "//third_party/android_platform/development/scripts:stack_py" ]
script = "//build/android/gyp/create_stack_script.py"
depfile = "$target_gen_dir/$target_name.d"
_stack_script = "//third_party/android_platform/development/scripts/stack"
_generated_script = "$root_build_dir/bin/stack_${_stack_target_name}"
outputs = [
_generated_script,
]
data = [
_generated_script,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--output-directory",
rebase_path(root_build_dir, root_build_dir),
"--script-path",
rebase_path(_stack_script, root_build_dir),
"--script-output-path",
rebase_path(_generated_script, root_build_dir),
"--arch=$target_cpu",
]
if (defined(invoker.packed_libraries)) {
args += [
"--packed-libs",
invoker.packed_libraries,
]
}
}
}
if (enable_java_templates) {
import("//build/config/zip.gni")
import("//third_party/ijar/ijar.gni")
import("//third_party/android_platform/config.gni")
android_sdk_jar = "$android_sdk/android.jar"
android_default_aapt_path = "$android_sdk_build_tools/aapt"
template("android_lint") {
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"data_deps",
"public_deps",
"testonly",
])
if (!defined(deps)) {
deps = []
}
if (defined(invoker.lint_suppressions_file)) {
lint_suppressions_file = invoker.lint_suppressions_file
} else if (!defined(lint_suppressions_file)) {
lint_suppressions_file = "//build/android/lint/suppressions.xml"
}
_lint_path = "$lint_android_sdk_root/tools/bin/lint"
_cache_dir = "$root_build_dir/android_lint_cache"
_result_path = "$target_gen_dir/$target_name/result.xml"
_config_path = "$target_gen_dir/$target_name/config.xml"
_suppressions_file = lint_suppressions_file
_platform_xml_path =
"${android_sdk_root}/platform-tools/api/api-versions.xml"
script = "//build/android/gyp/lint.py"
depfile = "$target_gen_dir/$target_name.d"
inputs = [
_platform_xml_path,
_suppressions_file,
]
outputs = [
_result_path,
_config_path,
]
args = [
"--lint-path",
rebase_path(_lint_path, root_build_dir),
"--cache-dir",
rebase_path(_cache_dir, root_build_dir),
"--platform-xml-path",
rebase_path(_platform_xml_path, root_build_dir),
"--android-sdk-version=${lint_android_sdk_version}",
"--depfile",
rebase_path(depfile, root_build_dir),
"--config-path",
rebase_path(_suppressions_file, root_build_dir),
"--product-dir=.",
"--processed-config-path",
rebase_path(_config_path, root_build_dir),
"--result-path",
rebase_path(_result_path, root_build_dir),
"--include-unexpected-failures",
]
if (defined(invoker.android_manifest)) {
inputs += [ invoker.android_manifest ]
args += [
"--manifest-path",
rebase_path(invoker.android_manifest, root_build_dir),
]
}
if (defined(invoker.disable)) {
args += [ "--disable=${invoker.disable}" ]
}
if (defined(invoker.create_cache) && invoker.create_cache) {
args += [
"--create-cache",
"--silent",
]
} else {
inputs += invoker.java_files
inputs += [
invoker.jar_path,
invoker.build_config,
]
if (invoker.java_files != []) {
inputs += [ invoker.java_sources_file ]
_rebased_java_sources_file =
rebase_path(invoker.java_sources_file, root_build_dir)
args += [ "--java-sources-file=$_rebased_java_sources_file" ]
}
deps += [ "//build/android:prepare_android_lint_cache" ]
_rebased_build_config =
rebase_path(invoker.build_config, root_build_dir)
args += [
"--jar-path",
rebase_path(invoker.jar_path, root_build_dir),
"--classpath=@FileArg($_rebased_build_config:javac:interface_classpath)",
"--srcjars=@FileArg($_rebased_build_config:gradle:bundled_srcjars)",
"--can-fail-build",
]
if (invoker.requires_android) {
args += [
"--resource-sources=@FileArg($_rebased_build_config:deps_info:owned_resources_dirs)",
"--resource-sources=@FileArg($_rebased_build_config:deps_info:owned_resources_zips)",
]
}
}
}
}
template("proguard") {
action(target_name) {
set_sources_assignment_filter([])
forward_variables_from(invoker,
[
"data",
"data_deps",
"deps",
"public_deps",
"testonly",
])
script = "//build/android/gyp/proguard.py"
# http://crbug.com/725224. Fix for bots running out of memory.
pool = "//build/toolchain:link_pool($default_toolchain)"
_output_jar_path = invoker.output_jar_path
_proguard_jar_path = _default_proguard_jar_path
if (defined(invoker.proguard_jar_path)) {
_proguard_jar_path = invoker.proguard_jar_path
}
inputs = [
_proguard_jar_path,
invoker.build_config,
]
if (defined(invoker.inputs)) {
inputs += invoker.inputs
}
depfile = "${target_gen_dir}/${target_name}.d"
outputs = [
_output_jar_path,
"$_output_jar_path.flags",
"$_output_jar_path.mapping",
"$_output_jar_path.seeds",
"$_output_jar_path.usage",
]
_rebased_build_config = rebase_path(invoker.build_config, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--proguard-path",
rebase_path(_proguard_jar_path, root_build_dir),
"--output-path",
rebase_path(_output_jar_path, root_build_dir),
"--classpath",
"@FileArg($_rebased_build_config:android:sdk_jars)",
]
if (proguard_verbose) {
args += [ "--verbose" ]
}
if (defined(invoker.args)) {
args += invoker.args
}
if (defined(invoker.proguard_jar_path)) {
# We assume that if we are using a different ProGuard, this new version
# can handle the 'dangerous' optimizaions.
args += [ "--enable-dangerous-optimizations" ]
}
}
}
# Generates a script in the build bin directory to run a java binary.
#
# Variables
# main_class: The class containing the program entry point.
# build_config: Path to .build_config for the jar (contains classpath).
# jar_path: Optional. First classpath entry to be inserted before
# the classpath extracted from the build_config.
# script_name: Name of the script to generate.
# wrapper_script_args: List of extra arguments to pass to the executable.
# bootclasspath: Optional. list of zip/jar file paths to add to the boot
# class path when the script will invoke javac.
#
template("java_binary_script") {
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"testonly",
])
_main_class = invoker.main_class
_build_config = invoker.build_config
_script_name = invoker.script_name
script = "//build/android/gyp/create_java_binary_script.py"
depfile = "$target_gen_dir/$_script_name.d"
_java_script = "$root_build_dir/bin/$_script_name"
inputs = [
_build_config,
]
outputs = [
_java_script,
]
_rebased_build_config = rebase_path(_build_config, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--output",
rebase_path(_java_script, root_build_dir),
"--main-class",
_main_class,
]
if (defined(invoker.jar_path)) {
_jar_path_list = [ rebase_path(invoker.jar_path, root_build_dir) ]
args += [ "--classpath=$_jar_path_list" ]
}
args += [ "--classpath=@FileArg($_rebased_build_config:deps_info:java_runtime_classpath)" ]
if (emma_coverage) {
args += [
"--classpath",
rebase_path("//third_party/android_tools/sdk/tools/lib/emma.jar",
root_build_dir),
"--noverify",
]
}
if (defined(invoker.wrapper_script_args)) {
args += [ "--" ] + invoker.wrapper_script_args
}
if (defined(invoker.bootclasspath)) {
args += [
"--bootclasspath",
rebase_path(invoker.bootclasspath, root_build_dir),
]
}
}
}
template("dex") {
_enable_multidex =
defined(invoker.enable_multidex) && invoker.enable_multidex
if (_enable_multidex) {
_main_dex_list_path = invoker.output + ".main_dex_list"
_main_dex_list_target_name = "${target_name}__main_dex_list"
action(_main_dex_list_target_name) {
forward_variables_from(invoker,
[
"deps",
"testonly",
])
script = "//build/android/gyp/main_dex_list.py"
depfile = "$target_gen_dir/$target_name.d"
# http://crbug.com/725224. Fix for bots running out of memory.
pool = "//build/toolchain:link_pool($default_toolchain)"
main_dex_rules = "//build/android/main_dex_classes.flags"
if (defined(invoker.proguard_jar_path)) {
_proguard_jar_path = invoker.proguard_jar_path
} else {
_proguard_jar_path = _default_proguard_jar_path
}
inputs = [
main_dex_rules,
_proguard_jar_path,
]
outputs = [
_main_dex_list_path,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--android-sdk-tools",
rebase_path(android_sdk_build_tools, root_build_dir),
"--main-dex-list-path",
rebase_path(_main_dex_list_path, root_build_dir),
"--main-dex-rules-path",
rebase_path(main_dex_rules, root_build_dir),
"--proguard-path",
rebase_path(_proguard_jar_path, root_build_dir),
]
if (defined(invoker.extra_main_dex_proguard_config)) {
inputs += [ invoker.extra_main_dex_proguard_config ]
args += [
"--main-dex-rules-path",
rebase_path(invoker.extra_main_dex_proguard_config, root_build_dir),
]
}
if (defined(invoker.negative_main_dex_globs)) {
args +=
[ "--negative-main-dex-globs=${invoker.negative_main_dex_globs}" ]
}
if (defined(invoker.input_jars_file_arg)) {
inputs += [ invoker.build_config ]
args += [ "--inputs=${invoker.input_jars_file_arg}" ]
}
if (defined(invoker.input_jars)) {
inputs += invoker.input_jars
args += rebase_path(invoker.input_jars, root_build_dir)
}
}
}
assert(defined(invoker.output))
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"testonly",
])
script = "//build/android/gyp/dex.py"
depfile = "$target_gen_dir/$target_name.d"
inputs = []
outputs = [
invoker.output,
]
if (defined(invoker.use_pool) && invoker.use_pool) {
pool = "//build/toolchain:link_pool($default_toolchain)"
}
_rebased_output = rebase_path(invoker.output, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--android-sdk-tools",
rebase_path(android_sdk_build_tools, root_build_dir),
"--dex-path",
_rebased_output,
]
if (enable_incremental_dx) {
args += [ "--incremental" ]
}
# EMMA requires --no-locals.
if (emma_coverage) {
args += [ "--no-locals=1" ]
}
if (_enable_multidex) {
args += [
"--multi-dex",
"--main-dex-list-path",
rebase_path(_main_dex_list_path, root_build_dir),
]
deps += [ ":${_main_dex_list_target_name}" ]
inputs += [ _main_dex_list_path ]
}
if (defined(invoker.input_jars_file_arg)) {
inputs += [ invoker.build_config ]
args += [ "--inputs=${invoker.input_jars_file_arg}" ]
}
if (defined(invoker.input_jars)) {
inputs += invoker.input_jars
args += rebase_path(invoker.input_jars, root_build_dir)
}
}
}
template("emma_instr") {
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
"testonly",
])
_coverage_file = "$target_out_dir/${target_name}.em"
_source_dirs_listing_file = "$target_out_dir/${target_name}_sources.txt"
_emma_jar = "${android_sdk_root}/tools/lib/emma.jar"
script = "//build/android/gyp/emma_instr.py"
depfile = "${target_gen_dir}/${target_name}.d"
inputs = invoker.java_files + [
_emma_jar,
invoker.input_jar_path,
]
outputs = [
_coverage_file,
_source_dirs_listing_file,
invoker.output_jar_path,
]
args = [
"instrument_jar",
"--input-path",
rebase_path(invoker.input_jar_path, root_build_dir),
"--output-path",
rebase_path(invoker.output_jar_path, root_build_dir),
"--depfile",
rebase_path(depfile, root_build_dir),
"--coverage-file",
rebase_path(_coverage_file, root_build_dir),
"--sources-list-file",
rebase_path(_source_dirs_listing_file, root_build_dir),
"--src-root",
rebase_path("//", root_build_dir),
"--emma-jar",
rebase_path(_emma_jar, root_build_dir),
]
_rebased_java_sources_file =
rebase_path(invoker.java_sources_file, root_build_dir)
args += [ "--java-sources-file=$_rebased_java_sources_file" ]
if (emma_filter != "") {
args += [
"--filter-string",
emma_filter,
]
}
}
}
# TODO(digit): Document this!
#
# Variables:
# testonly:
# build_config:
# input_jar_path:
# output_jar_path:
# enable_build_hooks:
# enable_build_hooks_android:
# supports_android:
# emma_instrument:
# jar_excluded_patterns: Optional list of .class file patterns to exclude
# from the final .jar file.
# jar_included_patterns: OPtional list of .class file patterns to include
# in the final .jar file. jar_excluded_patterns take precedence over this.
# strip_resource_classes:
# deps:
# java_files:
# java_sources_file:
# inputs:
# data_deps:
# visibility:
#
template("process_java_prebuilt") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
assert(invoker.build_config != "")
_build_config = invoker.build_config
_rebased_build_config = rebase_path(_build_config, root_build_dir)
assert(_rebased_build_config != "" || true) # Mark used.
_input_jar_path = invoker.input_jar_path
_output_jar_path = invoker.output_jar_path
_enable_assert =
defined(invoker.enable_build_hooks) && invoker.enable_build_hooks &&
(is_java_debug || dcheck_always_on || report_java_assert)
_enable_custom_resources = defined(invoker.enable_build_hooks_android) &&
invoker.enable_build_hooks_android
_desugar = defined(invoker.supports_android) && invoker.supports_android
_emma_instrument = invoker.emma_instrument
_jar_excluded_patterns = []
if (defined(invoker.jar_excluded_patterns)) {
_jar_excluded_patterns = invoker.jar_excluded_patterns
}
_jar_included_patterns = []
if (defined(invoker.jar_included_patterns)) {
_jar_included_patterns = invoker.jar_included_patterns
}
_strip_resource_classes = defined(invoker.strip_resource_classes) &&
invoker.strip_resource_classes
_filter_jar = _jar_excluded_patterns != [] ||
_jar_included_patterns != [] || _strip_resource_classes
_deps = []
_previous_output_jar = _input_jar_path
if (_enable_assert || _enable_custom_resources) {
_java_bytecode_rewriter_target = "${target_name}__bytecode_rewrite"
_java_bytecode_rewriter_input_jar = _previous_output_jar
_java_bytecode_rewriter_output_jar =
"$target_out_dir/$target_name-bytecode-rewritten.jar"
action(_java_bytecode_rewriter_target) {
script = "//build/android/gyp/bytecode_processor.py"
depfile = "$target_gen_dir/$target_name.d"
_bytecode_rewriter_script =
"$root_build_dir/bin/helper/java_bytecode_rewriter"
deps = [
"//build/android/bytecode:java_bytecode_rewriter($default_toolchain)",
]
deps += _deps
if (defined(invoker.deps)) {
deps += invoker.deps
}
inputs = [
_java_bytecode_rewriter_input_jar,
_build_config,
]
outputs = [
_java_bytecode_rewriter_output_jar,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--script",
rebase_path(_bytecode_rewriter_script, root_build_dir),
"--input-jar",
rebase_path(_java_bytecode_rewriter_input_jar, root_build_dir),
"--output-jar",
rebase_path(_java_bytecode_rewriter_output_jar, root_build_dir),
]
if (_enable_assert) {
args += [ "--enable-assert" ]
}
if (_enable_custom_resources) {
args += [ "--enable-custom-resources" ]
}
args += [
"--extra-classpath-jar",
"@FileArg($_rebased_build_config:android:sdk_jars)",
"--extra-classpath-jar",
"@FileArg($_rebased_build_config:deps_info:javac_full_classpath)",
]
}
_deps = []
_deps = [ ":$_java_bytecode_rewriter_target" ]
_previous_output_jar = _java_bytecode_rewriter_output_jar
}
if (_desugar) {
_desugar_target = "${target_name}__desugar"
_desugar_input_jar = _previous_output_jar
_desugar_output_jar = "$target_out_dir/$target_name-desugar.jar"
action(_desugar_target) {
script = "//build/android/gyp/desugar.py"
depfile = "$target_gen_dir/$target_name.d"
deps = _deps
if (defined(invoker.deps)) {
deps += invoker.deps
}
inputs = [
_build_config,
_desugar_input_jar,
]
outputs = [
_desugar_output_jar,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--input-jar",
rebase_path(_desugar_input_jar, root_build_dir),
"--output-jar",
rebase_path(_desugar_output_jar, root_build_dir),
"--classpath=@FileArg($_rebased_build_config:javac:interface_classpath)",
"--bootclasspath=@FileArg($_rebased_build_config:android:sdk_interface_jars)",
]
}
_deps = []
_deps = [ ":$_desugar_target" ]
_previous_output_jar = _desugar_output_jar
}
if (_filter_jar) {
_filter_target = "${target_name}__filter"
_filter_input_jar = _previous_output_jar
_filter_output_jar = "$target_out_dir/$target_name-filtered.jar"
action(_filter_target) {
script = "//build/android/gyp/jar.py"
deps = _deps
if (defined(invoker.deps)) {
deps += invoker.deps
}
inputs = [
_build_config,
_filter_input_jar,
]
outputs = [
_filter_output_jar,
]
args = [
"--input-jar",
rebase_path(_filter_input_jar, root_build_dir),
"--jar-path",
rebase_path(_filter_output_jar, root_build_dir),
"--excluded-classes=$_jar_excluded_patterns",
"--included-classes=$_jar_included_patterns",
]
if (_strip_resource_classes) {
args += [ "--strip-resource-classes-for=@FileArg($_rebased_build_config:javac:resource_packages)" ]
}
}
_deps = []
_deps = [ ":$_filter_target" ]
_previous_output_jar = _filter_output_jar
}
if (_emma_instrument) {
# Emma must run after desugar (or else desugar sometimes fails).
_emma_target = "${target_name}__emma"
_emma_input_jar = _previous_output_jar
_emma_output_jar = "$target_out_dir/$target_name-instrumented.jar"
emma_instr(_emma_target) {
deps = _deps
if (defined(invoker.deps)) {
deps += invoker.deps
}
forward_variables_from(invoker,
[
"java_files",
"java_sources_file",
])
input_jar_path = _emma_input_jar
output_jar_path = _emma_output_jar
}
_deps = []
_deps = [ ":$_emma_target" ]
_previous_output_jar = _emma_output_jar
}
_output_jar_target = "${target_name}__copy"
# This is copy_ex rather than copy to ensure that JARs (rather than
# possibly broken symlinks to them) get copied into the output
# directory.
copy_ex(_output_jar_target) {
forward_variables_from(invoker, [ "inputs" ])
deps = _deps
if (defined(invoker.deps)) {
deps += invoker.deps
}
dest = _output_jar_path
sources = [
_previous_output_jar,
]
outputs = [
_output_jar_path,
]
}
group(target_name) {
forward_variables_from(invoker,
[
"data_deps",
"visibility",
])
public_deps = [
":$_output_jar_target",
]
}
}
template("merge_manifests") {
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"testonly",
])
script = "//build/android/gyp/merge_manifest.py"
depfile = "$target_gen_dir/$target_name.d"
inputs = [
invoker.build_config,
invoker.input_manifest,
]
outputs = [
invoker.output_manifest,
]
_rebased_build_config = rebase_path(invoker.build_config, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--build-vars",
rebase_path(android_build_vars, root_build_dir),
"--root-manifest",
rebase_path(invoker.input_manifest, root_build_dir),
"--output",
rebase_path(invoker.output_manifest, root_build_dir),
"--extras",
"@FileArg($_rebased_build_config:extra_android_manifests)",
]
}
}
# This template is used to parse a set of resource directories and
# create the R.txt, .srcjar and .resources.zip for it.
#
# Input variables:
# deps: Specifies the input dependencies for this target.
#
# build_config: Path to the .build_config file corresponding to the target.
#
# resource_dirs:
# List of directories containing Android resources, layout should be
# similar to what aapt -S <dir> expects.
#
# generated_resource_dirs: (optional)
# List of directories containing generated resources.
#
# generated_resource_files: (optional)
# If generated_resources_dirs is not empty, must list all the files
# within these directories (the directory must appear at the start of
# the file path).
#
# custom_package: (optional)
# Package name for the generated R.java source file. Optional if
# android_manifest is not provided.
#
# android_manifest: (optional)
# If custom_package is not provided, path to an AndroidManifest.xml file
# that is only used to extract a package name out of it.
#
# r_text_in_path: (optional)
# Path to an input R.txt file to use to generate the R.java file.
# The default is to use 'aapt' to generate the file from the content
# of the resource directories.
#
# shared_resources: (optional)
# If true, generate an R.java file that uses non-final resource ID
# variables and an onResourcesLoaded() method.
#
# v14_skip: (optional)
# If true, skip generation of v14 compatible resources.
# (see generate_v14_compatible_resources.py for details).
#
# Output variables:
# zip_path: (optional)
# Path to a .resources.zip that will simply contain all the
# input resources, collected in a single archive.
#
# r_text_out_path: (optional): Path for the generated R.txt file.
#
# srcjar_path: (optional) Path to a generated .srcjar containing the
# generated R.java source file.
#
template("prepare_resources") {
if (defined(invoker.srcjar_path)) {
_srcjar_path = invoker.srcjar_path
}
action(target_name) {
set_sources_assignment_filter([])
forward_variables_from(invoker,
[
"deps",
"testonly",
"visibility",
])
script = "//build/android/gyp/prepare_resources.py"
depfile = "$target_gen_dir/${invoker.target_name}.d"
outputs = []
_all_resource_dirs = []
sources = []
if (defined(invoker.resource_dirs)) {
_all_resource_dirs += invoker.resource_dirs
# Speed up "gn gen" by short-circuiting the empty directory.
if (invoker.resource_dirs != [ "//build/android/empty" ] &&
invoker.resource_dirs != []) {
_sources_build_rel =
exec_script("//build/android/gyp/find.py",
rebase_path(invoker.resource_dirs, root_build_dir),
"list lines")
sources += rebase_path(_sources_build_rel, ".", root_build_dir)
}
}
if (defined(invoker.generated_resource_dirs)) {
assert(defined(invoker.generated_resource_files))
_all_resource_dirs += invoker.generated_resource_dirs
sources += invoker.generated_resource_files
}
_android_aapt_path = android_default_aapt_path
inputs = [
invoker.build_config,
_android_aapt_path,
]
_rebased_all_resource_dirs =
rebase_path(_all_resource_dirs, root_build_dir)
_rebased_build_config = rebase_path(invoker.build_config, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--android-sdk-jars=@FileArg($_rebased_build_config:android:sdk_jars)",
"--aapt-path",
rebase_path(_android_aapt_path, root_build_dir),
"--dependencies-res-zips=@FileArg($_rebased_build_config:resources:dependency_zips)",
"--extra-res-packages=@FileArg($_rebased_build_config:resources:extra_package_names)",
"--extra-r-text-files=@FileArg($_rebased_build_config:resources:extra_r_text_files)",
]
if (defined(invoker.android_manifest)) {
if (defined(invoker.android_manifest_dep)) {
deps += [ invoker.android_manifest_dep ]
}
inputs += [ invoker.android_manifest ]
args += [
"--android-manifest",
rebase_path(invoker.android_manifest, root_build_dir),
]
}
if (_rebased_all_resource_dirs != []) {
args += [ "--resource-dirs=$_rebased_all_resource_dirs" ]
}
if (defined(invoker.zip_path)) {
outputs += [
invoker.zip_path,
invoker.zip_path + ".info",
]
args += [
"--resource-zip-out",
rebase_path(invoker.zip_path, root_build_dir),
]
}
if (defined(invoker.r_text_out_path)) {
outputs += [ invoker.r_text_out_path ]
args += [
"--r-text-out",
rebase_path(invoker.r_text_out_path, root_build_dir),
]
}
if (defined(_srcjar_path)) {
outputs += [ _srcjar_path ]
args += [
"--srcjar-out",
rebase_path(_srcjar_path, root_build_dir),
]
}
if (defined(invoker.r_text_in_path)) {
_r_text_in_path = invoker.r_text_in_path
inputs += [ _r_text_in_path ]
args += [
"--r-text-in",
rebase_path(_r_text_in_path, root_build_dir),
]
}
if (defined(invoker.custom_package)) {
args += [
"--custom-package",
invoker.custom_package,
]
}
if (defined(invoker.shared_resources) && invoker.shared_resources) {
args += [ "--shared-resources" ]
}
if (defined(invoker.v14_skip) && invoker.v14_skip) {
args += [ "--v14-skip" ]
}
}
}
# A template that is used to compile all resources needed by a binary
# (e.g. an android_apk or a junit_binary) into an intermediate .ar_
# archive. It can also generate an associated .srcjar that contains the
# final R.java sources for all resource packages the binary depends on.
#
# Input variables:
# deps: Specifies the input dependencies for this target.
#
# build_config: Path to the .build_config file corresponding to the target.
#
# android_manifest: Path to root manifest for the binary.
#
# version_code: (optional)
#
# version_name: (optional)
#
# shared_resources: (optional)
# If true, make all variables in each generated R.java file non-final,
# and provide an onResourcesLoaded() method that can be used to reset
# their package index at load time. Useful when the APK corresponds to
# a library that is loaded at runtime, like system_webview_apk or
# monochrome_apk.
#
# app_as_shared_lib: (optional)
# If true, same effect as shared_resources, but also ensures that the
# resources can be used by the APK when it is loaded as a regular
# application as well. Useful for the monochrome_public_apk target
# which is both an application and a shared runtime library that
# implements the system webview feature.
#
# shared_resources_whitelist: (optional)
# Path to an R.txt file. If provided, acts similar to shared_resources
# except that it restricts the list of non-final resource variables
# to the list from the input R.txt file. Overrides shared_resources
# when both are specified.
#
# support_zh_hk: (optional)
# If true, support zh-HK in Chrome on Android by using the resources
# from zh-TW. See https://crbug.com/780847.
#
# aapt_locale_whitelist: (optional)
# Restrict compiled locale-dependent resources to a specific whitelist.
# NOTE: This is a list of Chromium locale names, not Android ones.
#
# exclude_xxxhdpi: (optional)
#
# xxxhdpi_whitelist: (optional)
#
# no_xml_namespaces: (optional)
#
# png_to_webp: (optional)
# If true, convert all PNG resources (except 9-patch files) to WebP.
#
# post_process_script: (optional)
#
# proto_format: (optional). If true, compiles resources into protocol
# buffer format.
#
# Output variables:
# output: Path to a zip file containing the compiled resources.
#
# r_text_out_path: (optional):
# Path for the corresponding generated R.txt file.
#
# srcjar_path: (optional)
# Path to a generated .srcjar containing the generated R.java sources
# for all dependent resource libraries.
#
# proguard_file: (optional)
# Path to proguard configuration file for this apk target.
#
# proguard_file_main_dex: (optional)
#
#
template("compile_resources") {
_compile_resources_target_name = target_name
_compiled_resources_path = invoker.output
if (defined(invoker.srcjar_path)) {
_srcjar_path = invoker.srcjar_path
}
if (defined(invoker.post_process_script)) {
_compile_resources_target_name = "${target_name}__intermediate"
_compiled_resources_path =
get_path_info(_compiled_resources_path, "dir") + "/" +
get_path_info(_compiled_resources_path, "name") + ".intermediate.ap_"
_srcjar_path = "${_srcjar_path}.intermediate.srcjar"
}
action(_compile_resources_target_name) {
set_sources_assignment_filter([])
forward_variables_from(invoker,
[
"deps",
"testonly",
"visibility",
])
script = "//build/android/gyp/compile_resources.py"
depfile = "$target_gen_dir/${invoker.target_name}_1.d"
outputs = []
_android_aapt_path = android_default_aapt_path
if (defined(invoker.proto_format) && invoker.proto_format) {
_android_aapt_path = "$android_sdk_app_bundle_build_tools/aapt"
}
inputs = [
invoker.build_config,
_android_aapt_path,
]
_rebased_build_config = rebase_path(invoker.build_config, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--android-sdk-jars=@FileArg($_rebased_build_config:android:sdk_jars)",
"--aapt-path",
rebase_path(_android_aapt_path, root_build_dir),
"--dependencies-res-zips=@FileArg($_rebased_build_config:resources:dependency_zips)",
"--extra-res-packages=@FileArg($_rebased_build_config:resources:extra_package_names)",
"--extra-r-text-files=@FileArg($_rebased_build_config:resources:extra_r_text_files)",
]
inputs += [ invoker.android_manifest ]
args += [
"--android-manifest",
rebase_path(invoker.android_manifest, root_build_dir),
]
if (defined(invoker.no_xml_namespaces) && invoker.no_xml_namespaces) {
args += [ "--no-xml-namespaces" ]
}
if (defined(invoker.version_code)) {
args += [
"--version-code",
invoker.version_code,
]
}
if (defined(invoker.version_name)) {
args += [
"--version-name",
invoker.version_name,
]
}
if (defined(_compiled_resources_path)) {
_info_path = invoker.output + ".info"
outputs += [
_compiled_resources_path,
_info_path,
]
args += [
"--apk-path",
rebase_path(_compiled_resources_path, root_build_dir),
"--apk-info-path",
rebase_path(_info_path, root_build_dir),
]
}
# Useful to have android:debuggable in the manifest even for Release
# builds. Just omit it for officai
if (debuggable_apks) {
args += [ "--debuggable" ]
}
if (defined(invoker.r_text_out_path)) {
outputs += [ invoker.r_text_out_path ]
args += [
"--r-text-out",
rebase_path(invoker.r_text_out_path, root_build_dir),
]
}
if (defined(_srcjar_path)) {
outputs += [ _srcjar_path ]
args += [
"--srcjar-out",
rebase_path(_srcjar_path, root_build_dir),
]
}
if (defined(invoker.custom_package)) {
args += [
"--custom-package",
invoker.custom_package,
]
}
_proto_format = defined(invoker.proto_format) && invoker.proto_format
if (_proto_format) {
args += [ "--proto-format" ]
}
# Define the flags related to shared resources.
#
# Note the small sanity check to ensure that the package ID of the
# generated resources table is correct. It should be 0x02 for runtime
# shared libraries, and 0x7f otherwise.
_expected_resources_pkg_id = "0x7f"
if (defined(invoker.shared_resources) && invoker.shared_resources) {
args += [ "--shared-resources" ]
_expected_resources_pkg_id = "0x02"
} else if (defined(invoker.app_as_shared_lib) &&
invoker.app_as_shared_lib) {
args += [ "--app-as-shared-lib" ]
}
# NOTE: It is not possible to check the resources package ID of
# proto-compiled APKs at the moment.
if (!_proto_format) {
args += [ "--check-resources-pkg-id=$_expected_resources_pkg_id" ]
} else {
assert(_expected_resources_pkg_id != "") # Mark as used.
}
if (defined(invoker.shared_resources_whitelist)) {
inputs += [ invoker.shared_resources_whitelist ]
args += [
"--shared-resources-whitelist",
rebase_path(invoker.shared_resources_whitelist, root_build_dir),
]
}
if (defined(invoker.proguard_file)) {
outputs += [ invoker.proguard_file ]
args += [
"--proguard-file",
rebase_path(invoker.proguard_file, root_build_dir),
]
}
if (defined(invoker.proguard_file_main_dex)) {
outputs += [ invoker.proguard_file_main_dex ]
args += [
"--proguard-file-main-dex",
rebase_path(invoker.proguard_file_main_dex, root_build_dir),
]
}
if (defined(invoker.aapt_locale_whitelist)) {
args += [ "--locale-whitelist=${invoker.aapt_locale_whitelist}" ]
}
if (defined(invoker.png_to_webp) && invoker.png_to_webp) {
_webp_target = "//third_party/libwebp:cwebp($host_toolchain)"
_webp_binary = get_label_info(_webp_target, "root_out_dir") + "/cwebp"
deps += [ _webp_target ]
inputs += [ _webp_binary ]
args += [
"--png-to-webp",
"--webp-binary",
rebase_path(_webp_binary, root_build_dir),
]
}
if (defined(invoker.exclude_xxxhdpi) && invoker.exclude_xxxhdpi) {
args += [ "--exclude-xxxhdpi" ]
if (defined(invoker.xxxhdpi_whitelist)) {
args += [ "--xxxhdpi-whitelist=${invoker.xxxhdpi_whitelist}" ]
}
}
if (defined(invoker.support_zh_hk) && invoker.support_zh_hk) {
args += [ "--support-zh-hk" ]
}
if (defined(invoker.args)) {
args += invoker.args
}
}
if (defined(invoker.post_process_script)) {
action(target_name) {
depfile = "${target_gen_dir}/${invoker.target_name}_2.d"
script = invoker.post_process_script
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--apk-path",
rebase_path(_compiled_resources_path, root_build_dir),
"--output",
rebase_path(invoker.output, root_build_dir),
"--srcjar-in",
rebase_path(_srcjar_path, root_build_dir),
"--srcjar-out",
rebase_path(invoker.srcjar_path, root_build_dir),
]
if (defined(invoker.shared_resources_whitelist)) {
args += [
"--r-text-whitelist",
rebase_path(invoker.shared_resources_whitelist, root_build_dir),
"--r-text",
rebase_path(invoker.r_text_out_path, root_build_dir),
]
}
inputs = [
_srcjar_path,
_compiled_resources_path,
]
outputs = [
invoker.output,
invoker.srcjar_path,
]
public_deps = [
":${_compile_resources_target_name}",
]
}
}
}
# Compile resources for an APK.
#
# This is very similar to compile_resources, except that it can *also*
# compile the same set of inputs using the new protocol-buffer based
# format, if proto_outut and proto_resources_target are set.
#
# Takes the same variables as compile_resources, with the following
# extras:
#
# proto_output: optional. If provided, the path to an output file that
# will contain the resources compiled in the new protocol buffer format.
# proto_resources_target: required when proto_output is set. Name of the
# target associated with compiling the protocol-buffer based resources.
#
template("compile_apk_resources") {
# First call to compile_resources() is used to generate the compiled
# resources using the standard binary xml + resources.arsc format.
compile_resources(target_name) {
forward_variables_from(invoker,
"*",
[
"proto_format",
"proto_output",
"proto_resources_target",
])
}
# The second call is optional, and is only used to compile the resources
# using the new protocol buffer based format. This omits the generation of
# R.txt, /srcjar and proguard files (performed during the first call), or
# resources post-processing.
if (defined(invoker.proto_output)) {
compile_resources(invoker.proto_resources_target) {
forward_variables_from(invoker,
"*",
[
"output",
"post_process_script",
"proguard_file",
"proguard_file_main_dex",
"proto_output",
"proto_resources_target",
"r_text_out_path",
"srcjar_path",
])
output = invoker.proto_output
proto_format = true
}
}
}
# Create an apk.jar.info file by merging several .jar.info files into one.
#
# Variables:
# apk_build_config: Path to APK's build config file. Used to extract the
# list of input .jar files from its dependencies.
# output: Output file path.
#
template("create_apk_jar_info") {
_output = invoker.output
_build_config = invoker.apk_build_config
_rebased_build_config = rebase_path(_build_config, root_build_dir)
action(target_name) {
forward_variables_from(invoker,
[
"testonly",
"deps",
])
script = "//build/android/gyp/merge_jar_info_files.py"
inputs = [
_build_config,
]
outputs = [
_output,
]
depfile = "$target_gen_dir/$target_name.d"
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--output",
rebase_path(_output, root_build_dir),
"--apk-jar-file=@FileArg($_rebased_build_config:deps_info:jar_path)",
"--dep-jar-files=@FileArg(" +
"$_rebased_build_config:deps_info:javac_full_classpath)",
]
}
}
# Creates a signed and aligned .apk.
#
# Variables
# apk_name: (optional) APK name (without .apk suffix). If provided, will
# be used to generate .info files later used by the supersize tool.
# assets_build_config: Path to android_apk .build_config containing merged
# asset information.
# deps: Specifies the dependencies of this target.
# dex_path: Path to classes.dex file to include (optional).
# packaged_resources_path: Path to .ap_ to use.
# output_apk_path: Output path for the generated .apk.
# 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).
# native_libs: List of native libraries.
# native_libs_filearg: @FileArg() of additionally native libraries.
# secondary_abi_native_libs: (optional) List of native libraries for
# secondary ABI.
# secondary_abi_native_libs_filearg: (optiona). @FileArg() of additional
# secondary ABI native libs.
# write_asset_list: Adds an extra file to the assets, which contains a list of
# all other asset files.
# keystore_path: Path to keystore to use for signing.
# keystore_name: Key alias to use.
# keystore_password: Keystore password.
# uncompress_shared_libraries: (optional, default false) Whether to store
# native libraries inside the APK uncompressed and page-aligned.
template("package_apk") {
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
"testonly",
])
_native_lib_placeholders = []
if (defined(invoker.native_lib_placeholders)) {
_native_lib_placeholders = invoker.native_lib_placeholders
}
_secondary_native_lib_placeholders = []
if (defined(invoker.secondary_native_lib_placeholders)) {
_secondary_native_lib_placeholders =
invoker.secondary_native_lib_placeholders
}
script = "//build/android/gyp/apkbuilder.py"
depfile = "$target_gen_dir/$target_name.d"
_apksigner = "$android_sdk_build_tools/apksigner"
_zipalign = "$android_sdk_build_tools/zipalign"
data_deps = [
"//tools/android/md5sum",
] # Used when deploying APKs
inputs = invoker.native_libs + [
invoker.keystore_path,
invoker.packaged_resources_path,
_apksigner,
_zipalign,
]
if (defined(invoker.dex_path)) {
inputs += [ invoker.dex_path ]
}
outputs = [
invoker.output_apk_path,
]
data = [
invoker.output_apk_path,
]
_rebased_compiled_resources_path =
rebase_path(invoker.packaged_resources_path, root_build_dir)
_rebased_packaged_apk_path =
rebase_path(invoker.output_apk_path, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--resource-apk=$_rebased_compiled_resources_path",
"--output-apk=$_rebased_packaged_apk_path",
"--apksigner-path",
rebase_path(_apksigner, root_build_dir),
"--zipalign-path",
rebase_path(_zipalign, root_build_dir),
"--key-path",
rebase_path(invoker.keystore_path, root_build_dir),
"--key-name",
invoker.keystore_name,
"--key-passwd",
invoker.keystore_password,
]
if (defined(invoker.assets_build_config)) {
inputs += [ invoker.assets_build_config ]
_rebased_build_config =
rebase_path(invoker.assets_build_config, root_build_dir)
args += [
"--assets=@FileArg($_rebased_build_config:assets)",
"--uncompressed-assets=@FileArg($_rebased_build_config:uncompressed_assets)",
]
# TODO(mlopatkin) We are relying on the fact that assets_build_config is
# an APK build_config.
args += [ "--java-resources=@FileArg($_rebased_build_config:java_resources_jars)" ]
if (defined(invoker.apk_name)) {
# The supersize tool will search in this directory for each apk.
_apk_pak_info_path = "size-info/${invoker.apk_name}.apk.pak.info"
_apk_res_info_path = "size-info/${invoker.apk_name}.apk.res.info"
args += [
"--apk-pak-info-path",
_apk_pak_info_path,
"--apk-res-info-path",
_apk_res_info_path,
]
outputs += [
"$root_build_dir/$_apk_pak_info_path",
"$root_build_dir/$_apk_res_info_path",
]
}
}
if (defined(invoker.write_asset_list) && invoker.write_asset_list) {
args += [ "--write-asset-list" ]
}
if (defined(invoker.dex_path)) {
_rebased_dex_path = rebase_path(invoker.dex_path, root_build_dir)
args += [ "--dex-file=$_rebased_dex_path" ]
}
if (invoker.native_libs != [] || defined(invoker.native_libs_filearg) ||
_native_lib_placeholders != []) {
args += [ "--android-abi=$android_app_abi" ]
}
if (defined(invoker.secondary_abi_native_libs_filearg) ||
(defined(invoker.secondary_native_libs) &&
invoker.secondary_native_libs != []) ||
_secondary_native_lib_placeholders != []) {
assert(defined(android_app_secondary_abi))
args += [ "--secondary-android-abi=$android_app_secondary_abi" ]
}
if (invoker.native_libs != []) {
_rebased_native_libs = rebase_path(invoker.native_libs, root_build_dir)
args += [ "--native-libs=$_rebased_native_libs" ]
}
if (defined(invoker.native_libs_filearg)) {
args += [ "--native-libs=${invoker.native_libs_filearg}" ]
}
if (_native_lib_placeholders != []) {
args += [ "--native-lib-placeholders=$_native_lib_placeholders" ]
}
if (_secondary_native_lib_placeholders != []) {
args += [ "--secondary-native-lib-placeholders=$_secondary_native_lib_placeholders" ]
}
# TODO (michaelbai): Remove the secondary_native_libs variable.
if (defined(invoker.secondary_abi_native_libs_filearg)) {
args += [ "--secondary-native-libs=${invoker.secondary_abi_native_libs_filearg}" ]
} else if (defined(invoker.secondary_native_libs) &&
invoker.secondary_native_libs != []) {
inputs += invoker.secondary_native_libs
_secondary_native_libs = rebase_path(invoker.secondary_native_libs)
args += [ "--secondary-native-libs=$_secondary_native_libs" ]
}
if (defined(invoker.uncompress_shared_libraries) &&
invoker.uncompress_shared_libraries) {
args += [ "--uncompress-shared-libraries=True" ]
}
}
}
# Packages resources, assets, dex, and native libraries into an apk. Signs and
# zipaligns the apk.
template("create_apk") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
_android_manifest = invoker.android_manifest
_base_path = invoker.base_path
_final_apk_path = invoker.apk_path
_incremental_final_apk_path_helper =
process_file_template(
[ _final_apk_path ],
"{{source_dir}}/{{source_name_part}}_incremental.apk")
_incremental_final_apk_path = _incremental_final_apk_path_helper[0]
if (defined(invoker.dex_path)) {
_dex_path = invoker.dex_path
}
_load_library_from_apk = invoker.load_library_from_apk
assert(_load_library_from_apk || true)
_deps = []
if (defined(invoker.deps)) {
_deps = invoker.deps
}
_incremental_deps = []
if (defined(invoker.incremental_deps)) {
_incremental_deps = invoker.incremental_deps
}
_native_libs = []
if (defined(invoker.native_libs)) {
_native_libs = invoker.native_libs
}
_native_libs_even_when_incremental = []
if (defined(invoker.native_libs_even_when_incremental)) {
_native_libs_even_when_incremental =
invoker.native_libs_even_when_incremental
}
_incremental_compiled_resources_path = "${_base_path}_incremental.ap_"
_shared_resources =
defined(invoker.shared_resources) && invoker.shared_resources
assert(_shared_resources || true) # Mark as used.
_keystore_path = invoker.keystore_path
_keystore_name = invoker.keystore_name
_keystore_password = invoker.keystore_password
_incremental_compile_resources_target_name =
"${target_name}_incremental__compile_resources"
_incremental_android_manifest =
get_label_info(_incremental_compile_resources_target_name,
"target_gen_dir") + "/AndroidManifest.xml"
_rebased_build_config =
rebase_path(invoker.assets_build_config, root_build_dir)
action(_incremental_compile_resources_target_name) {
deps = _incremental_deps
script =
"//build/android/incremental_install/generate_android_manifest.py"
inputs = [
# Save on a depfile by listing only .py dep here.
"//build/android/gyp/util/build_utils.py",
_android_manifest,
invoker.packaged_resources_path,
]
outputs = [
# Output the non-compiled manifest for easy debugging (as opposed to
# generating to a temp file).
_incremental_android_manifest,
_incremental_compiled_resources_path,
]
args = [
"--src-manifest",
rebase_path(_android_manifest, root_build_dir),
"--out-manifest",
rebase_path(_incremental_android_manifest, root_build_dir),
"--in-apk",
rebase_path(invoker.packaged_resources_path, root_build_dir),
"--out-apk",
rebase_path(_incremental_compiled_resources_path, root_build_dir),
"--aapt-path",
rebase_path(android_default_aapt_path, root_build_dir),
"--android-sdk-jars=@FileArg($_rebased_build_config:android:sdk_jars)",
]
if (disable_incremental_isolated_processes) {
args += [ "--disable-isolated-processes" ]
}
}
package_apk(target_name) {
forward_variables_from(invoker,
[
"apk_name",
"assets_build_config",
"native_lib_placeholders",
"native_libs_filearg",
"packaged_resources_path",
"secondary_native_lib_placeholders",
"secondary_abi_native_libs_filearg",
"secondary_native_libs",
"uncompress_shared_libraries",
"write_asset_list",
])
if (!defined(uncompress_shared_libraries)) {
uncompress_shared_libraries = _load_library_from_apk
}
deps = _deps
native_libs = _native_libs + _native_libs_even_when_incremental
keystore_path = _keystore_path
keystore_name = _keystore_name
keystore_password = _keystore_password
if (defined(_dex_path)) {
dex_path = _dex_path
}
output_apk_path = _final_apk_path
}
package_apk("${target_name}_incremental") {
forward_variables_from(invoker,
[
"assets_build_config",
"secondary_native_libs",
"uncompress_shared_libraries",
])
if (!defined(uncompress_shared_libraries)) {
uncompress_shared_libraries = _load_library_from_apk
}
_dex_target = "//build/android/incremental_install:bootstrap_java__dex"
deps = _incremental_deps + [
":${_incremental_compile_resources_target_name}",
_dex_target,
]
if (defined(_dex_path)) {
dex_path =
get_label_info(_dex_target, "target_gen_dir") + "/bootstrap.dex"
}
native_libs = _native_libs_even_when_incremental
keystore_path = _keystore_path
keystore_name = _keystore_name
keystore_password = _keystore_password
# http://crbug.com/384638
_has_native_libs =
defined(invoker.native_libs_filearg) || _native_libs != []
if (_has_native_libs && _native_libs_even_when_incremental == []) {
native_lib_placeholders = [ "libfix.crbug.384638.so" ]
}
output_apk_path = _incremental_final_apk_path
packaged_resources_path = _incremental_compiled_resources_path
}
}
# Compile Java source files into a .jar file, potentially using an
# annotation processor, and/or the errorprone compiler.
#
# Note that the only way to specify custom annotation processors is
# by using build_config to point to a file that corresponds to a java-related
# target that includes javac:processor_classes entries (i.e. there is no
# variable here that can be used for this purpose).
#
# Note also the peculiar use of java_files / java_sources_file. The content
# of the java_files list and the java_sources_file file must match exactly.
# This rule uses java_files only to list the inputs to the action that
# calls the javac.py script, but will pass the list of Java source files
# with the '@${java_sources_file}" command-line syntax. Not a problem in
# practice since this is only called from java_library_impl() that sets up
# the variables properly.
#
# Variables:
# java_files: Optional list of Java source file paths.
# srcjar_deps: Optional list of .srcjar dependencies (not file paths).
# The corresponding source files they contain will be compiled too.
# srcjar_filearg: Optional @FileArg for additional srcjars.
# java_sources_file: Optional path to file containing list of Java source
# file paths. This must always be provided if java_files is not empty
# and must match it exactly.
# build_config: Path to the .build_config file of the corresponding
# java_library_impl() target. The following entries will be used by this
# template: javac:srcjars, deps_info:javac_full_classpath,
# deps_info:javac_full_interface_classpath, javac:processor_classpath,
# javac:processor_classes
# javac_jar_path: Path to the final output .jar file.
# javac_args: Optional list of extra arguments to pass to javac.
# chromium_code: Whether this corresponds to Chromium-specific sources.
# requires_android: True if these sources can only run on Android.
# additional_jar_files: Optional list of files to copy into the resulting
# .jar file (by default, only .class files are put there). Each entry
# has the 'srcPath:dstPath' format.
# enable_incremental_javac_override: Optional. If provided, determines
# whether incremental javac compilation (based on jmake) is enabled.
# Otherwise, decision is based on the global enable_incremental_javac
# build arg variable.
# enable_errorprone: Optional. If True, use the errorprone compiler to
# check for error-prone constructs in the language. If not provided,
# whether this is enabled depends on chromium_code and the global
# use_errorprone_java_compiler variable.
# apk_name: Optional APK name. If provided, will tell javac.py to also
# generate an .apk.jar.info file under size-info/${apk_name}.apk.jar.info
# provider_configurations: Optional list of paths to Java service
# provider configuration files [1]. These will be copied under
# META-INF/services/ in the final .jar file.
# processor_args_javac: List of annotation processor arguments, each one
# will be passed to javac as -A<entry>.
# deps: Dependencies for the corresponding target.
# testonly: Usual meaning (should be True for test-only targets)
#
# [1] https://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html
#
template("compile_java") {
forward_variables_from(invoker, [ "testonly" ])
_build_config = invoker.build_config
_chromium_code = invoker.chromium_code
if (defined(invoker.enable_errorprone)) {
_enable_errorprone = invoker.enable_errorprone
} else {
_enable_errorprone = use_errorprone_java_compiler && _chromium_code
}
_provider_configurations = []
if (defined(invoker.provider_configurations)) {
_provider_configurations = invoker.provider_configurations
}
_processor_args = []
if (defined(invoker.processor_args_javac)) {
_processor_args = invoker.processor_args_javac
}
_additional_jar_files = []
if (defined(invoker.additional_jar_files)) {
_additional_jar_files = invoker.additional_jar_files
}
if (defined(invoker.enable_incremental_javac_override)) {
# Use invoker-specified override.
_enable_incremental_javac = invoker.enable_incremental_javac_override
} else {
# Default to build arg if not overridden.
_enable_incremental_javac = enable_incremental_javac
}
_srcjar_deps = []
if (defined(invoker.srcjar_deps)) {
_srcjar_deps += invoker.srcjar_deps
}
_java_srcjars = []
foreach(dep, _srcjar_deps) {
_dep_gen_dir = get_label_info(dep, "target_gen_dir")
_dep_name = get_label_info(dep, "name")
_java_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
}
_javac_args = []
if (defined(invoker.javac_args)) {
_javac_args = invoker.javac_args
}
action(target_name) {
script = "//build/android/gyp/javac.py"
depfile = "$target_gen_dir/$target_name.d"
deps = _srcjar_deps
if (defined(invoker.deps)) {
deps += invoker.deps
}
outputs = [
invoker.javac_jar_path,
invoker.javac_jar_path + ".md5.stamp",
invoker.javac_jar_path + ".info",
]
inputs = invoker.java_files + _java_srcjars + [ _build_config ]
if (invoker.java_files != []) {
inputs += [ invoker.java_sources_file ]
}
_rebased_build_config = rebase_path(_build_config, root_build_dir)
_rebased_javac_jar_path =
rebase_path(invoker.javac_jar_path, root_build_dir)
_rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
_rebased_depfile = rebase_path(depfile, root_build_dir)
args = [
"--depfile=$_rebased_depfile",
"--jar-path=$_rebased_javac_jar_path",
"--java-srcjars=$_rebased_java_srcjars",
"--java-version=1.8",
"--full-classpath=@FileArg($_rebased_build_config:deps_info:javac_full_classpath)",
"--interface-classpath=@FileArg($_rebased_build_config:deps_info:javac_full_interface_classpath)",
"--processorpath=@FileArg($_rebased_build_config:javac:processor_classpath)",
"--processors=@FileArg($_rebased_build_config:javac:processor_classes)",
]
if (defined(invoker.srcjar_filearg)) {
args += [ "--java-srcjars=${invoker.srcjar_filearg}" ]
}
if (_enable_incremental_javac) {
args += [ "--incremental" ]
deps += [ "//third_party/jmake($default_toolchain)" ]
inputs += [ "$root_build_dir/bin/jmake" ]
outputs += [ "${invoker.javac_jar_path}.pdb" ]
}
if (invoker.requires_android) {
args += [ "--bootclasspath=@FileArg($_rebased_build_config:android:sdk_interface_jars)" ]
}
if (_chromium_code) {
args += [ "--chromium-code=1" ]
}
if (_enable_errorprone) {
deps += [ "//third_party/errorprone:errorprone($default_toolchain)" ]
deps += [ "//tools/android/errorprone_plugin:errorprone_plugin_java($default_toolchain)" ]
_rebased_errorprone_processorpath = [
"lib.java/tools/android/errorprone_plugin/errorprone_plugin_java.jar",
]
args += [
"--use-errorprone-path",
"bin/errorprone",
"--processorpath=$_rebased_errorprone_processorpath",
]
}
foreach(e, _provider_configurations) {
args += [ "--provider-configuration=" + rebase_path(e, root_build_dir) ]
}
foreach(e, _processor_args) {
args += [ "--processor-arg=" + e ]
}
foreach(file_tuple, _additional_jar_files) {
# Each element is of length two, [ path_to_file, path_to_put_in_jar ]
inputs += [ file_tuple[0] ]
args +=
[ "--additional-jar-file=" + file_tuple[0] + ":" + file_tuple[1] ]
}
if (invoker.java_files != []) {
args += [ "@" + rebase_path(invoker.java_sources_file, root_build_dir) ]
}
foreach(e, _javac_args) {
args += [ "--javac-arg=" + e ]
}
}
}
# A rule that will handle multiple Java-related targets.
#
# The caller can provide a list of source files with 'java_files'
# and 'srcjar_deps', or a prebuilt .jar file through 'jar_path'.
#
# In the case of a 'java_binary' target type, it can even provide none of
# that (and the rule will just generate its wrapper script).
#
# The template will process the input .jar file (either the prebuilt one,
# or the result of compiling the sources), for example to apply Proguard,
# but also other ranges of bytecode-level rewriting schemes.
#
# Variables:
# type: type of Java target, valid values: 'java_library', 'java_binary',
# 'junit_binary', 'java_annotation_processor', and 'android_apk'
# main_target_name: optional. If provided, overrides target_name when
# creating sub-targets (e.g. "${main_target_name}__build_config") and
# some output files (e.g. "${main_target_name}.sources"). Only used
# for 'android_apk' types at the moment, where main_target_name will
# be the name of the main APK target.
# supports_android: Optional. True if target can run on Android.
# requires_android: Optional. True if target can only run on Android.
# java_files: Optional list of Java source file paths for this target.
# srcjar_deps: Optional list of .srcjar targets (not file paths). The Java
# source files they contain will also be compiled for this target.
# java_sources_file: Optional path to a file which will be written with
# the content of java_files. If not provided, the file will be written
# under $target_gen_dir/$main_target_name.sources. Ignored if
# java_files is empty. If not
# jar_path: Optional path to a prebuilt .jar file for this target.
# Mutually exclusive with java_files and srcjar_deps.
# final_jar_path: Optional path to the final output .jar file (after
# processing). If not provided, the output will go under
# $root_build_dir/lib.java/
# output_name: Optional output name for the final jar path. Ignored if
# final_jar_path is provided. Otherwise, used to determine the name
# of the final jar. If not provided, the default is to use the same
# name as jar_path, if provided, or main_target_name.
# dex_path: Optional. Path to the output dex.jar file for this target.
# Ignored if !supports_android.
# main_class: Main Java class name for 'java_binary', 'junit_binary' and
# 'java_annotation_processor' target types. Should not be set for other
# ones.
# deps: Dependencies for this target.
# testonly: True iff target should only be used for tests.
# no_build_hooks: Disables bytecode rewriting of asserts and android
# resources methods.
# chromium_code: Optional. Whether this is Chromium-specific code. If not
# provided, this is determined automatically, based on the location of
# the source files (i.e. anything under third_party/ is not
# Chromium-specific unless it is in a 'chromium' sub-directory).
# emma_never_instrument: Optional. If provided, whether to forbid
# instrumentation with the Emma coverage processor. If not provided,
# this is controlled by the global emma_coverage build arg variable
# and only used for non-test Chromium code.
# include_android_sdk: Optional. Whether or not the android SDK dep
# should be added to deps. Defaults to true for non-system libraries
# that support android.
# alternative_android_sdk_dep: Optional. Alternative Android system
# android java target to use.
# annotation_processor_deps: Optional list of dependencies corresponding
# to annotation processors used to compile these sources.
# input_jars_paths: Optional list of additional .jar file paths, which will
# be added to the compile-time classpath when building this target (but
# not to the runtime classpath).
# classpath_deps: Optional list of additional java library dependencies,
# whose .jar files will be added to the compile-time classpath when
# building this target (but not to the runtime classpath).
# gradle_treat_as_prebuilt: Cause generate_gradle.py to reference this
# library via its built .jar rather than including its .java sources.
# proguard_enabled: Optional. True to enable ProGuard obfuscation.
# proguard_configs: Optional list of additional proguard config file paths.
# bypass_platform_checks: Optional. If True, platform checks will not
# be performed. They are used to verify that every target with
# requires_android only depends on targets that, at least supports_android.
# Similarly, if a target has !supports_android, then it cannot depend on
# any other target that has requires_android.
# include_java_resources: Optional. If True, include Java (not Android)
# resources into final .jar file.
# android_manifest_for_lint: Optional path to Android manifest to use
# if Android linting is enabled. Ignored for 'android_apk' types
# (since the value of android_manifest will be used instead).
# lint_suppressions_file: Optional lint suppressions input file.
# jar_excluded_patterns: Optional list of .class file patterns to exclude
# from the final .jar file.
# jar_included_patterns: Optional list of .class file patterns to include
# in the final .jar file. jar_excluded_patterns take precedence over this.
#
# For 'android_apk' targets only:
#
# apk_path: Path to the final APK file.
# android_manifest: Path to AndroidManifest.xml file for the APK.
# android_manifest_dep: Optional. Dependency target that generates
# android_manifest.
# apk_under_test: For 'android_apk' targets used to test other APKs,
# this is the target name of APK being tested.
# incremental_allowed: Optional (default false). True to allow the
# generation of incremental APKs ('android_apk' targets only).
# incremental_apk_path: If incremental_allowed, path to the incremental
# output APK.
# incremental_install_json_path: If incremental_allowed, path to the output
# incremental install json configuration file.
# non_native_packed_relocations: Optional. True if the target Android
# system does not support compressed relocations in native shared
# libraries.
# shared_libraries_runtime_deps_file: Optional. Path to a file listing the
# native shared libraries required at runtime by the APK.
# secondary_abi_shared_libraries_runtime_deps_file:
# extra_shared_libraries: Optional list of extra native libraries to
# be stored in the APK.
# uncompress_shared_libraries: Optional. True to store native shared
# libraries uncompressed and page-aligned.
#
# For 'java_binary' and 'junit_binary' targets only. Ignored by others:
#
# bootclasspath: Optional list of boot class paths used by the generated
# wrapper script.
# wrapper_script_name: Optional name for the generated wrapper script.
# Default is main target name.
# wrapper_script_args: Optional list of extra arguments used by the
# generated wrapper script.
#
template("java_library_impl") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
_is_prebuilt = defined(invoker.jar_path)
_is_annotation_processor = invoker.type == "java_annotation_processor"
_is_java_binary =
invoker.type == "java_binary" || invoker.type == "junit_binary"
_is_system_library = invoker.type == "system_java_library"
_supports_android =
defined(invoker.supports_android) && invoker.supports_android
_requires_android =
defined(invoker.requires_android) && invoker.requires_android
_main_target_name = target_name
if (defined(invoker.main_target_name)) {
_main_target_name = invoker.main_target_name
}
_java_files = []
if (defined(invoker.java_files)) {
_java_files = invoker.java_files
}
_srcjar_deps = []
if (defined(invoker.srcjar_deps)) {
_srcjar_deps = invoker.srcjar_deps
}
_has_sources = _java_files != [] || _srcjar_deps != []
if (_is_prebuilt) {
assert(!_has_sources)
} else {
# Allow java_binary to not specify any sources. This is needed when a prebuilt
# is needed as a library as well as a binary.
assert(_is_annotation_processor || _is_java_binary || _has_sources)
}
if (_is_java_binary) {
assert(defined(invoker.main_class),
"${invoker.type}() must set main_class")
} else if (_is_annotation_processor) {
assert(defined(invoker.main_class),
"java_annotation_processor() must set main_class")
} else {
assert(!defined(invoker.main_class),
"main_class cannot be used for target of type ${invoker.type}")
}
# The only target that might have no prebuilt and no sources is a java_binary.
if (_is_prebuilt || _has_sources) {
if (defined(invoker.output_name)) {
_output_name = invoker.output_name
} else if (_is_prebuilt) {
_output_name = get_path_info(invoker.jar_path, "name")
} else {
_output_name = _main_target_name
}
# Jar files can be needed at runtime (by Robolectric tests or java binaries),
# so do not put them under gen/.
_target_dir_name = get_label_info(":$_main_target_name", "dir")
_final_jar_path =
"$root_out_dir/lib.java$_target_dir_name/$_output_name.jar"
if (defined(invoker.final_jar_path)) {
_final_jar_path = invoker.final_jar_path
}
_final_ijar_path =
get_path_info(_final_jar_path, "dir") + "/" +
get_path_info(_final_jar_path, "name") + ".interface.jar"
if (_has_sources) {
_javac_jar_path = "$target_gen_dir/$_main_target_name.javac.jar"
}
if (_is_prebuilt) {
_unprocessed_jar_path = invoker.jar_path
} else {
_unprocessed_jar_path = _javac_jar_path
}
if (_supports_android) {
_dex_path = "$target_gen_dir/$_main_target_name.dex.jar"
if (defined(invoker.dex_path)) {
_dex_path = invoker.dex_path
}
}
}
_accumulated_deps = []
if (defined(invoker.deps)) {
_accumulated_deps = invoker.deps
}
_accumulated_deps += [ "//build/config:exe_and_shlib_deps" ]
_enable_build_hooks =
_supports_android &&
(!defined(invoker.no_build_hooks) || !invoker.no_build_hooks)
if (_enable_build_hooks) {
_accumulated_deps += [ "//build/android/buildhooks:build_hooks_java" ]
}
# Some testonly targets use their own resources and the code being
# tested will use custom resources so there's no need to enable this
# for testonly targets.
_enable_build_hooks_android =
_enable_build_hooks && _requires_android &&
(!defined(invoker.testonly) || !invoker.testonly)
if (_enable_build_hooks_android) {
_accumulated_deps +=
[ "//build/android/buildhooks:build_hooks_android_java" ]
}
# Don't enable coverage or lint unless the target has some non-generated
# files.
if (defined(invoker.chromium_code)) {
_chromium_code = invoker.chromium_code
} else {
# Default based on whether target is in third_party.
set_sources_assignment_filter([ "*\bthird_party\b*" ])
sources = [
get_label_info(":$_main_target_name", "dir"),
]
_chromium_code = sources != []
if (!_chromium_code && !_is_prebuilt && _java_files != []) {
# Unless third_party code has an org.chromium file in it.
set_sources_assignment_filter([ "*\bchromium\b*" ])
sources = _java_files
_chromium_code = _java_files != sources
}
set_sources_assignment_filter([])
sources = []
}
if (defined(_final_jar_path)) {
_emma_instrument = emma_coverage && _chromium_code && _java_files != [] &&
(!defined(invoker.testonly) || !invoker.testonly)
if (defined(invoker.emma_never_instrument)) {
_emma_instrument = !invoker.emma_never_instrument && _emma_instrument
}
if (_emma_instrument) {
_accumulated_deps += [ "//third_party/android_tools:emma_device_java" ]
}
}
if (_java_files != []) {
_java_sources_file = "$target_gen_dir/$_main_target_name.sources"
if (defined(invoker.java_sources_file)) {
_java_sources_file = invoker.java_sources_file
}
write_file(_java_sources_file, rebase_path(_java_files, root_build_dir))
}
_include_android_sdk = !_is_system_library && _supports_android
if (defined(invoker.include_android_sdk)) {
_include_android_sdk = invoker.include_android_sdk
}
if (_include_android_sdk) {
if (defined(invoker.alternative_android_sdk_dep)) {
_accumulated_deps += [ invoker.alternative_android_sdk_dep ]
} else {
_accumulated_deps += [ "//build/android:android_sdk_java" ]
}
}
# Define build_config_deps which will be a list of targets required to
# build the _build_config.
_build_config = "$target_gen_dir/$_main_target_name.build_config"
_build_config_target_name = "${_main_target_name}__build_config"
write_build_config(_build_config_target_name) {
forward_variables_from(invoker,
[
"annotation_processor_deps",
"classpath_deps",
"gradle_treat_as_prebuilt",
"proguard_enabled",
"proguard_configs",
"input_jars_paths",
"main_class",
"type",
])
if (type == "android_apk") {
forward_variables_from(
invoker,
[
"android_manifest",
"android_manifest_dep",
"apk_path",
"apk_under_test",
"extra_shared_libraries",
"incremental_allowed",
"incremental_apk_path",
"incremental_install_json_path",
"non_native_packed_relocations",
"proto_resources_path",
"secondary_abi_shared_libraries_runtime_deps_file",
"shared_libraries_runtime_deps_file",
"uncompress_shared_libraries",
])
}
build_config = _build_config
is_prebuilt = _is_prebuilt
possible_config_deps = _accumulated_deps
if (defined(apk_under_test)) {
possible_config_deps += [ apk_under_test ]
}
supports_android = _supports_android
requires_android = _requires_android
bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
invoker.bypass_platform_checks
if (defined(_final_jar_path)) {
jar_path = _final_jar_path
ijar_path = _final_ijar_path
unprocessed_jar_path = _unprocessed_jar_path
}
if (defined(_dex_path)) {
dex_path = _dex_path
}
if (_java_files != []) {
java_sources_file = _java_sources_file
}
bundled_srcjars = []
foreach(d, _srcjar_deps) {
_dep_gen_dir = get_label_info(d, "target_gen_dir")
_dep_name = get_label_info(d, "name")
bundled_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
}
if (defined(invoker.include_java_resources) &&
invoker.include_java_resources) {
# Use original jar_path because _jar_path points to a library without
# resources.
java_resources_jar = invoker.jar_path
}
}
_accumulated_deps += [ ":$_build_config_target_name" ]
# Don't need to depend on the apk-under-test to be packaged.
if (defined(invoker.apk_under_test)) {
_accumulated_deps += [ "${invoker.apk_under_test}__java" ]
}
if (defined(invoker.android_manifest_dep)) {
_accumulated_deps += [ invoker.android_manifest_dep ]
}
if (defined(invoker.classpath_deps)) {
_accumulated_deps += invoker.classpath_deps
}
if (defined(invoker.annotation_processor_deps)) {
_accumulated_deps += invoker.annotation_processor_deps
}
# TODO(agrieve): Enable lint for _has_sources rather than just _java_files.
_has_lint_target = _java_files != [] && _supports_android && _chromium_code
if (_has_sources) {
_compile_java_target = "${_main_target_name}__compile_java"
compile_java(_compile_java_target) {
forward_variables_from(invoker,
[
"additional_jar_files",
"apk_name",
"enable_errorprone",
"enable_incremental_javac_override",
"processor_args_javac",
"provider_configurations",
"javac_args",
])
build_config = _build_config
java_files = _java_files
if (_java_files != []) {
java_sources_file = _java_sources_file
}
srcjar_deps = _srcjar_deps
chromium_code = _chromium_code
requires_android = _requires_android
deps = _accumulated_deps
javac_jar_path = _javac_jar_path
# android_apk and junit_binary pass R.java srcjars via srcjar_deps.
if (invoker.type == "java_library" && _requires_android) {
_rebased_build_config = rebase_path(_build_config, root_build_dir)
srcjar_filearg = "@FileArg($_rebased_build_config:deps_info:owned_resource_srcjars)"
}
}
_accumulated_deps += [ ":$_compile_java_target" ]
if (_has_lint_target) {
android_lint("${_main_target_name}__lint") {
if (invoker.type == "android_apk") {
forward_variables_from(invoker, [ "android_manifest" ])
} else if (defined(invoker.android_manifest_for_lint)) {
android_manifest = invoker.android_manifest_for_lint
}
build_config = _build_config
requires_android = _requires_android
jar_path = _javac_jar_path
deps = _accumulated_deps
java_files = _java_files
if (_java_files != []) {
java_sources_file = _java_sources_file
}
if (defined(invoker.lint_suppressions_file)) {
lint_suppressions_file = invoker.lint_suppressions_file
}
}
# Use an intermediate group() rather as the data_deps target in order to
# avoid lint artifacts showing up as runtime_deps (while still having lint
# run in parallel to other targets).
group("${_main_target_name}__analysis") {
public_deps = [
":${_main_target_name}__lint",
]
}
}
} # _has_sources
if (defined(_final_jar_path)) {
if (_is_system_library) {
_copy_system_library_target_name = "${target_name}__copy_system_library"
# Use copy_ex rather than copy to ensure that we copy symlink targets
# rather than the symlink itself.
copy_ex(_copy_system_library_target_name) {
sources = [
_unprocessed_jar_path,
]
dest = _final_jar_path
outputs = [
_final_jar_path,
]
}
_accumulated_deps += [ ":$_copy_system_library_target_name" ]
} else {
_process_prebuilt_target_name = "${target_name}__process_prebuilt"
process_java_prebuilt(_process_prebuilt_target_name) {
forward_variables_from(invoker,
[
"jar_excluded_patterns",
"jar_included_patterns",
])
supports_android = _supports_android
enable_build_hooks = _enable_build_hooks
enable_build_hooks_android = _enable_build_hooks_android
build_config = _build_config
input_jar_path = _unprocessed_jar_path
emma_instrument = _emma_instrument
if (_emma_instrument) {
java_files = _java_files
java_sources_file = _java_sources_file
}
output_jar_path = _final_jar_path
deps = _accumulated_deps
}
_accumulated_deps += [ ":$_process_prebuilt_target_name" ]
if (defined(_dex_path)) {
dex("${target_name}__dex") {
input_jars = [ _final_jar_path ]
output = _dex_path
deps = [
":$_process_prebuilt_target_name",
]
}
_accumulated_deps += [ ":${target_name}__dex" ]
}
}
_ijar_target_name = "${target_name}__ijar"
generate_interface_jar(_ijar_target_name) {
# Always used the unfiltered .jar to create the interface jar so that
# other targets will resolve filtered classes when depending on
# BuildConfig, NativeLibraries, etc.
input_jar = _unprocessed_jar_path
if (_is_prebuilt) {
forward_variables_from(invoker, [ "deps" ])
} else {
deps = [
":$_compile_java_target",
]
}
output_jar = _final_ijar_path
}
_accumulated_deps += [ ":$_ijar_target_name" ]
}
if (_is_java_binary) {
# Targets might use the generated script while building, so make it a dep
# rather than a data_dep.
java_binary_script("${target_name}__java_binary_script") {
forward_variables_from(invoker,
[
"bootclasspath",
"main_class",
"wrapper_script_args",
])
build_config = _build_config
if (defined(_final_jar_path)) {
jar_path = _final_jar_path
}
script_name = _main_target_name
if (defined(invoker.wrapper_script_name)) {
script_name = invoker.wrapper_script_name
}
deps = _accumulated_deps
}
_accumulated_deps += [ ":${target_name}__java_binary_script" ]
}
group(target_name) {
forward_variables_from(invoker,
[
"data",
"data_deps",
"visibility",
])
public_deps = _accumulated_deps
if (_has_lint_target) {
if (!defined(data_deps)) {
data_deps = []
}
data_deps += [ ":${_main_target_name}__analysis" ]
}
}
}
template("pack_relocation_section") {
assert(defined(invoker.file_list_json))
assert(defined(invoker.libraries_filearg))
action(target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
"inputs",
"testonly",
])
script = "//build/android/gyp/pack_relocations.py"
depfile = "$target_gen_dir/$target_name.d"
_packed_libraries_dir = "$target_gen_dir/$target_name/packed-libs"
outputs = [
invoker.file_list_json,
]
deps += [ relocation_packer_target ]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--enable-packing=1",
"--android-pack-relocations",
rebase_path(relocation_packer_exe, 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=${invoker.libraries_filearg}",
"--filelistjson",
rebase_path(invoker.file_list_json, root_build_dir),
]
}
}
}
Reference in New Issue View Git Blame Copy Permalink