# Copyright 2015 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import("//android_webview/variables.gni")
import("//base/android/linker/config.gni")
import("//base/android/resource_exclusions.gni")
import("//build/config/android/rules.gni")
import("//build/config/compiler/compiler.gni")
import("//build/config/locales.gni")
import("//build/toolchain/gcc_toolchain.gni")
import("//chrome/android/features/dev_ui/dev_ui_module.gni")
import("//chrome/android/modules/chrome_bundle_tmpl.gni")
import("//chrome/android/trichrome.gni")
import("//chrome/common/features.gni")
import("//chrome/version.gni")
import("//components/crash/android/silent_java_assert_reporting.gni")
import("//device/vr/buildflags/buildflags.gni")
import("channel.gni")
declare_args() {
# Android package name to use when compiling the public chrome targets
# (chrome_public_apk, monochrome_public_apk, etc. as well as the
# *_bundle variants). This is particularly useful when using
# monochrome_public_apk for WebView development, as the OS only accepts
# WebView providers which declare one of a handful of package names. See
# https://chromium.googlesource.com/chromium/src/+/HEAD/android_webview/docs/build-instructions.md#Changing-package-name
# for details.
chrome_public_manifest_package = "org.chromium.chrome"
if (use_stable_package_name_for_trichrome) {
chrome_public_manifest_package += ".stable"
} else if (android_channel != "default") {
chrome_public_manifest_package += "." + android_channel
}
}
chrome_public_test_manifest_package = "org.chromium.chrome.tests"
default_chrome_public_jinja_variables = [
"channel=$android_channel",
"enable_cardboard=$enable_cardboard",
"enable_vr=$enable_vr",
"enable_openxr=$enable_openxr",
"enable_arcore=$enable_arcore",
"zygote_preload_class=org.chromium.content_public.app.ZygotePreload",
]
monochrome_android_manifest_jinja_variables =
[ "sandboxed_service_exported=true" ]
# Generates an AndroidManifest.xml along with an optional second manifest
# dependent on the original.
#
# Variables:
# input: The base manifest template with the main application definition.
# output: Output path for |input|.
# split_input: Path to an alternate manifest that will be built if
# definitions_in_split is true.
# split_output: Output path for |split_input|.
# variables: Variables to pass to the jinja templates.
# definitions_in_split: If true will pass definitions_in_split=true in the
# variables passed to |input| and generate |split_output|.
template("split_manifest_template") {
_definitions_in_split =
defined(invoker.definitions_in_split) && invoker.definitions_in_split
jinja_template(target_name) {
forward_variables_from(invoker,
[
"includes",
"input",
"output",
"variables",
])
if (_definitions_in_split) {
variables += [ "definitions_in_split=true" ]
}
}
if (_definitions_in_split) {
jinja_template("${target_name}__split") {
forward_variables_from(invoker,
[
"includes",
"variables",
])
if (!defined(includes)) {
includes = []
}
includes += [ invoker.input ]
input = invoker.split_input
output = invoker.split_output
_rebased_input = rebase_path(invoker.input, "//")
variables += [ "base_manifest=${_rebased_input}" ]
}
} else {
not_needed(invoker,
[
"split_input",
"split_output",
])
}
}
# A template used to declare any target that will implement a full Chromium
# or Chrome application, either as an APK, or an app bundle module.
#
# Variables:
# target_type: Either 'android_apk' or 'android_app_bundle_module'.
# apk_name: For APK target types, the final APK name without a suffix.
# shared_libraries: List of native shared libraries targets to include in
# the final target (e.g. [ ":libchrome" ]).
# is_monochrome: Indicates that this target contains chrome and webview
# packaged together and can only run on Android N+.
# is_trichrome: Indicates this target relies on a trichrome static library
# target and can only run on Android P+.
# png_to_webp: Optional. If true, convert image resources to webp format.
# requires Android K+, since these were not supported by Android properly
# before 4.3.0.
#
# Plus all other variables accepted by android_apk() or
# android_app_bundle_module(), depending on the target type.
#
template("chrome_common_apk_or_module_tmpl") {
forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
_target_type = invoker.target_type
assert(_target_type == "android_apk" ||
_target_type == "android_app_bundle_module" ||
_target_type == "instrumentation_test_apk")
_is_monochrome = defined(invoker.is_monochrome) && invoker.is_monochrome
_is_trichrome = defined(invoker.is_trichrome) && invoker.is_trichrome
_is_bundle = _target_type == "android_app_bundle_module"
_is_test = _target_type == "instrumentation_test_apk"
assert(!(_is_test && _is_monochrome), "Unsupported configuration")
assert(!(_is_test && _is_trichrome), "Unsupported configuration")
if (_is_test) {
testonly = true
}
_is_64_bit_browser =
android_64bit_target_cpu &&
(!defined(invoker.is_64_bit_browser) || invoker.is_64_bit_browser)
if (_is_trichrome || _is_monochrome) {
_include_64_bit_webview =
android_64bit_target_cpu && (!defined(invoker.include_64_bit_webview) ||
invoker.include_64_bit_webview)
_include_32_bit_webview = !defined(invoker.include_32_bit_webview) ||
invoker.include_32_bit_webview
_include_primary_abi = !android_64bit_target_cpu || _is_64_bit_browser ||
_include_64_bit_webview
_include_secondary_abi = android_64bit_target_cpu &&
(!_is_64_bit_browser || _include_32_bit_webview)
if (_include_secondary_abi) {
_secondary_out_dir =
get_label_info("X($android_secondary_abi_toolchain)", "root_out_dir")
not_needed([ "_secondary_out_dir" ])
}
}
assert(!(_is_monochrome && _is_trichrome),
"Cannot be both trichrome and monochrome!")
assert(_is_trichrome == defined(invoker.static_library_provider),
"If trichrome library is used, static_library_provider must be set " +
"so that a dep can be added on the library APK.")
if (_is_trichrome) {
_version_code = TRICHROME_VERSION_MAP["${android_64bit_target_cpu}_${_is_64_bit_browser}_${_include_64_bit_webview}_${_include_32_bit_webview}"]
} else if (_is_monochrome) {
_version_code = MONOCHROME_VERSION_MAP["${android_64bit_target_cpu}_${_is_64_bit_browser}_${_include_64_bit_webview}_${_include_32_bit_webview}"]
} else {
_version_code = chrome_version_code
}
if (defined(invoker.version_code)) {
_version_code = invoker.version_code
}
# Need to apply override explicitly to have it apply to library version.
if (android_override_version_code != "") {
_version_code = android_override_version_code
}
if (defined(invoker.manifest_package)) {
_manifest_package = invoker.manifest_package
} else if (_is_test) {
_manifest_package = chrome_public_test_manifest_package
} else {
_manifest_package = chrome_public_manifest_package
}
_android_manifest = "$target_gen_dir/$target_name/AndroidManifest.xml"
_split_android_manifest =
"$target_gen_dir/$target_name/AndroidManifest_split.xml"
_android_manifest_target_name = "${target_name}__android_manifest"
split_manifest_template(_android_manifest_target_name) {
definitions_in_split = _is_bundle
split_input = "//chrome/android/java/AndroidManifest_split.xml"
split_output = _split_android_manifest
includes = []
output = _android_manifest
variables = default_chrome_public_jinja_variables +
[ "manifest_package=$_manifest_package" ]
if (_is_trichrome) {
input = "//chrome/android/java/AndroidManifest_trichrome_chrome.xml"
includes = [ "//chrome/android/java/AndroidManifest.xml" ]
variables +=
trichrome_jinja_variables + [ "trichrome_version=$_version_code" ]
} else if (_is_monochrome) {
input = "//chrome/android/java/AndroidManifest_monochrome.xml"
includes = [
"//android_webview/nonembedded/java/AndroidManifest.xml",
"//chrome/android/java/AndroidManifest.xml",
]
variables += monochrome_android_manifest_jinja_variables
if (_is_64_bit_browser) {
variables += [ "webview_library=libmonochrome_64.so" ]
} else {
variables += [ "webview_library=libmonochrome.so" ]
}
} else {
input = "//chrome/android/java/AndroidManifest.xml"
}
if (_is_monochrome || _is_trichrome) {
_force_32_bit = _include_32_bit_webview && _include_64_bit_webview &&
!_is_64_bit_browser
variables += [ "force_32_bit=$_force_32_bit" ]
}
if (_is_test) {
includes += [ input ]
input = "//chrome/android/javatests/AndroidManifest.xml"
}
if (defined(invoker.jinja_input)) {
includes += [ input ]
input = invoker.jinja_input
}
if (defined(invoker.jinja_extra_variables)) {
variables += invoker.jinja_extra_variables
}
if (defined(invoker.jinja_extra_includes)) {
includes += invoker.jinja_extra_includes
}
}
target(_target_type, target_name) {
android_manifest = _android_manifest
android_manifest_dep = ":$_android_manifest_target_name"
manifest_package = _manifest_package
if (defined(invoker.min_sdk_version)) {
min_sdk_version = invoker.min_sdk_version
} else if (_is_trichrome) {
min_sdk_version = 29
}
if (defined(invoker.version_name)) {
version_name = invoker.version_name
} else {
version_name = chrome_version_name
}
if (defined(invoker.version_code)) {
# Override for the actual versionCode, but not for trichrome_version.
version_code = invoker.version_code
} else {
version_code = _version_code
}
if (defined(invoker.expected_android_manifest)) {
if (android_64bit_target_cpu) {
_version_code_offset = chrome_32_version_code
} else {
_version_code_offset = chrome_version_code
}
expected_android_manifest_version_code_offset = _version_code_offset
expected_android_manifest_library_version_offset = _version_code_offset
}
if (_target_type == "android_apk") {
command_line_flags_file = "chrome-command-line"
}
if (_is_bundle) {
is_base_module = true
# Sets ISOLATED_SPLITS_ENABLED in BuildConfig.java.
isolated_splits_enabled = true
}
product_config_java_packages = [ "org.chromium.chrome.browser" ]
if (_is_monochrome) {
alternative_android_sdk_dep = webview_framework_dep
app_as_shared_lib = true
# Resource allowlist used when generating R.java files and causes
# only the webview subset of resources to be marked as non-final.
# Strings in this target will also be kept in the base apk rather than placed in the language splits.
shared_resources_allowlist_target =
"//android_webview:system_webview_no_weblayer_apk"
# Ensure the localized resources for all locales are used, even when
# a smaller set is specified through aapt_locale_allowlist.
shared_resources_allowlist_locales = platform_pak_locales
product_config_java_packages += [ webview_product_config_java_package ]
}
if (enable_silent_java_assert_reporting) {
custom_assertion_handler = crash_reporting_assertion_handler
}
# Include resource strings files only for supported locales.
aapt_locale_allowlist = platform_pak_locales
resource_exclusion_regex = common_resource_exclusion_regex
resource_exclusion_exceptions = common_resource_exclusion_exceptions
# Exceptions (rationale in https://crbug.com/691733):
resource_exclusion_exceptions += [
"*ic_file_download_white*", # Bottom edge seems misaligned.
"*ic_lock.*", # Bottom edge seems misaligned.
]
# Most of these, with the exception of resource_exclusion_exceptions,
# are currently duplicated in system_webview_apk_tmpl.gni.
# Used only by alert dialog on tiny screens.
_material_package = "com_google_android_material.*"
resource_exclusion_regex += "|${_material_package}values-small"
# Used only by date picker (which chrome doesn't use).
resource_exclusion_regex += "|${_material_package}-(w480dp-port|w360dp-port|h480dp-land|h360dp-land)"
# Material design layouts that cause views to be kept that we don't use.
# Instead of manually filtering, unused resource removal would be better:
# https://crbug.com/636448
resource_exclusion_regex += "|${_material_package}/xml.*badge_"
if (!is_java_debug) {
# TODO(crbug.com/41475795): Update test goldens with webp versions of images.
if (!_is_test) {
png_to_webp = true
}
proguard_enabled = true
proguard_configs = [ "//chrome/android/proguard/main.flags" ]
if (_is_monochrome) {
proguard_configs +=
[ "//android_webview/nonembedded/java/proguard.flags" ]
}
if (_is_test) {
proguard_configs += [ "//chrome/android/proguard/apk_for_test.flags" ]
}
if (defined(invoker.proguard_configs)) {
proguard_configs += invoker.proguard_configs
}
# We only optimize resources for bundles since APKs are not shipped.
# Resources only live in the base module atm as such we only need to set
# these on the base module
if (_is_bundle) {
# Removes metadata needed for Resources.getIdentifier("resource_name").
strip_resource_names = true
# Shortens resource file names in apk eg: res/drawable/button.xml -> res/a.xml
short_resource_paths = true
# Removes unused resources from the apk. Only enabled on official builds
# since it adds a slow step and serializes the build graph causing fewer
# expensive tasks (eg: proguarding, resource optimization) to be run in
# parallel by adding dependencies between them (adds around 10-20
# seconds on my machine).
strip_unused_resources = is_official_build
# Resources config for blocklisting resource names from obfuscation
resources_config_paths = [ "//chrome/android/aapt2.config" ]
if (_is_monochrome) {
resources_config_paths += [ "//android_webview/aapt2.config" ]
}
if (defined(invoker.resources_config_paths)) {
resources_config_paths += invoker.resources_config_paths
}
}
}
# shared_resources_allowlist_target causes a native dep to appear via resources.
if (!_is_monochrome) {
# Java and native targets form two independent compile graphs. Deps from java targets
# onto native ones (or vice versa) are unnecessary and reduce parallelism.
# This prevents most deps from java->native.
# One common violation is generate_jni() targets, which generate
# .srcjars, but also .h files, and so export their native deps.
# Tip: If the dep is due to loadable_modules or android_assets, use "asset_deps" rather than
# "deps".
assert_no_native_deps = [
"//base",
"//build/config/compiler:compiler_buildflags",
"//build/rust:cxx_cppdeps",
"//third_party/abseil-cpp:absl",
]
}
deps = [ "//chrome/android:chrome_base_module_resources" ]
# TODO(agrieve): Make unconditional when moving to trampoline.
if (_is_monochrome || _is_trichrome) {
deps += [ "//components/crash/android:handler_java" ]
}
if (_is_monochrome) {
deps += [ "//chrome/android:base_monochrome_module_java" ]
} else {
deps += [ "//chrome/android:base_module_java" ]
}
if (defined(invoker.deps)) {
deps += invoker.deps
}
if (!_is_trichrome) {
# These go in trichrome library.
deps += [
"//gin:v8_snapshot_assets",
"//third_party/icu:icu_assets",
]
# TODO(agrieve): This is excluded from trichrome in preparation for
# "synchronized proguarding", which we've since abandoned. Enable for
# trichrome, or just remove the version check altogether.
build_config_include_product_version_resource = true
deps += [ "//chrome/android:product_version_resources" ]
}
if (_is_bundle) {
# Required to support macro resources.
# See https://crbug.com/1278419
deps += [ ":${target_name}__all_dfm_resources" ]
} else {
# For bundles, this exists in the "chrome" split.
deps += [ "//chrome/android:chrome_all_java" ]
if (dfmify_dev_ui) {
# For bundles, Dev UI is a feature in a DFM.
deps += [ "//chrome/android/features/dev_ui:java" ]
}
}
if (_is_monochrome) {
deps += [
"//android_webview/glue:glue_java",
"//android_webview/nonembedded:monochrome_devui_launcher_icon_resources",
"//android_webview/nonembedded:nonembedded_java",
]
# For bundles, this lives in chrome split.
if (!_is_bundle) {
deps += [ "//chrome/android:monochrome_java" ]
}
if (_include_primary_abi) {
deps += [ "//android_webview:monochrome_webview_primary_abi_assets" ]
}
if (_include_secondary_abi) {
deps += [ "//android_webview:monochrome_webview_secondary_abi_assets" ]
}
}
asset_deps = [ "//chrome/android:chrome_public_non_pak_assets" ]
if (defined(invoker.asset_deps)) {
asset_deps += invoker.asset_deps
}
if (_is_bundle && _is_monochrome) {
asset_deps += [ "//chrome/android:monochrome_bundle_module_pak_assets" ]
} else if (_is_bundle && _is_trichrome) {
asset_deps +=
[ "//chrome/android:trichrome_chrome_bundle_module_pak_assets" ]
} else if (_is_bundle) {
asset_deps += [ "//chrome/android:chrome_bundle_module_pak_assets" ]
} else if (_is_monochrome) {
asset_deps += [ "//chrome/android:monochrome_apk_pak_assets" ]
} else {
assert(!_is_trichrome)
asset_deps += [ "//chrome/android:chrome_apk_pak_assets" ]
}
if (_is_trichrome) {
# Only the .build_config.json is used from this target, and it's fine if
# it contains more assets than we need (always use the 64_32 variant).
# https://crbug.com/357131361
suffix_apk_assets_used_by = system_webview_apk_target
}
if (defined(invoker.add_upstream_only_deps) &&
invoker.add_upstream_only_deps) {
if (_is_monochrome) {
deps += upstream_only_webview_deps
} else if (!_is_trichrome) {
deps += [
"//chrome/android:chrome_public_apk_base_module_resources",
"//components/browser_ui/styles/android:chrome_public_apk_resources",
]
asset_deps += [ "//chrome/android:chrome_public_non_pak_assets" ]
}
if (_is_bundle) {
deps += [
# deps in delegate_public_impl_java are put into the Chrome module, but the language deps
# are needed by the base module.
"//components/language/android:ulp_delegate_public_java",
]
if (_is_monochrome) {
# WebView needs these in the base module.
deps += [
"//content/public/android:identity_credentials_public_impl_java",
]
}
} else {
deps += [
"//chrome/android:chrome_all_java",
"//chrome/android:delegate_public_impl_java",
]
}
if (_is_test) {
deps += [ "//chrome/android:chrome_public_base_module_java_for_test" ]
}
}
# Chrome uses the window APIs directly instead of going through the
# androidx middleware.
# See //third_party/android_sdk/window_extensions/README.md
assert_no_deps = [
"//third_party/android_deps:org_jetbrains_kotlin_kotlin_parcelize_runtime",
"//third_party/androidx:androidx_window_extensions_core_core_java",
"//third_party/androidx:androidx_window_sidecar_sidecar_java",
"//third_party/androidx:androidx_window_window_java_java",
]
if (defined(invoker.assert_no_deps)) {
assert_no_deps += invoker.assert_no_deps
}
# Unwind tables are included in the stack_unwinder DFM on Android, so they
# aren't needed for bundle builds. However, we keep them for non-bundle
# builds, such as test and development apks (e.g. chrome_public_apk), to
# allow tests and developers to use them directly.
if (!defined(invoker.shared_libraries) && !_is_bundle &&
add_unwind_tables_in_chrome_32bit_apk &&
(target_cpu == "arm" ||
(target_cpu == "arm64" && !_is_64_bit_browser))) {
if (_is_test) {
asset_deps +=
[ "//chrome/android:libchromefortest_unwind_table_assets" ]
} else if (_is_monochrome || _is_trichrome) {
asset_deps += [ "//chrome/android:libmonochrome_unwind_table_assets" ]
} else {
asset_deps += [ "//chrome/android:libchrome_unwind_table_assets" ]
}
}
data_deps = []
if (defined(invoker.data_deps)) {
data_deps += invoker.data_deps
}
# Prefer to add this data_dep on the final target instead of java targets
# like chrome_all_java so that all other targets can build in parallel with
# lint.
if (!disable_android_lint) {
data_deps += [ "//chrome/android:android_lint" ]
}
# Official builds need the dump_syms binary for symbolizing. This is a small
# binary necessary for debugging official builds. Ensure it is built.
if (is_official_build) {
data_deps += [ "//third_party/breakpad:dump_syms" ]
}
shared_libraries = []
loadable_modules = []
if (android_64bit_target_cpu) {
secondary_abi_shared_libraries = []
secondary_abi_loadable_modules = []
}
if (defined(invoker.loadable_modules)) {
loadable_modules = invoker.loadable_modules
}
if (defined(invoker.secondary_abi_loadable_modules)) {
secondary_abi_loadable_modules = invoker.secondary_abi_loadable_modules
}
if (_is_64_bit_browser && build_hwasan_splits) {
_hwasan_toolchain = "//build/toolchain/android:android_clang_arm64_hwasan"
}
if (defined(invoker.shared_libraries)) {
shared_libraries += invoker.shared_libraries
} else if (_is_test) {
shared_libraries += [ "//chrome/android:libchromefortest" ]
srcjar_deps = [ "//chrome/android:libchromefortest__jni_registration($default_toolchain)" ]
} else if (_is_monochrome || _is_trichrome) {
# We are only doing the jni_registrations for Trichrome - the actual
# native libraries will end up in the Trichrome library.
if (android_64bit_target_cpu) {
# Build //android_webview:monochrome with the opposite bitness that
# Chrome runs in.
if (_is_64_bit_browser) {
srcjar_deps = [ "//chrome/android:libmonochrome_64__jni_registration($default_toolchain)" ]
if (_is_monochrome) {
shared_libraries += [ "//chrome/android:libmonochrome_64" ]
if (_include_32_bit_webview) {
secondary_abi_shared_libraries += [ "//android_webview:monochrome_64($android_secondary_abi_toolchain)" ]
}
if (build_hwasan_splits) {
shared_libraries +=
[ "//chrome/android:libmonochrome_64($_hwasan_toolchain)" ]
}
}
} else {
srcjar_deps = [ "//chrome/android:libmonochrome__jni_registration($default_toolchain)" ]
if (_is_monochrome) {
if (_include_64_bit_webview) {
shared_libraries += [ "//android_webview:monochrome" ]
}
secondary_abi_shared_libraries += [ "//chrome/android:libmonochrome($android_secondary_abi_toolchain)" ]
}
}
} else {
srcjar_deps = [ "//chrome/android:libmonochrome__jni_registration($default_toolchain)" ]
if (_is_monochrome) {
shared_libraries += [ "//chrome/android:libmonochrome" ]
}
}
} else if (!_is_trichrome) {
shared_libraries += [ "//chrome/android:libchrome" ]
srcjar_deps =
[ "//chrome/android:libchrome__jni_registration($default_toolchain)" ]
}
if (defined(invoker.srcjar_deps)) {
srcjar_deps += invoker.srcjar_deps
}
if (enable_arcore) {
# The arcore manifest needs to be merged into the base module because
# the Play Store verifies the com.google.ar.core.min_apk_version
# meta-data tag is in the base manifest.
deps += [
"//third_party/arcore-android-sdk-client:arcore_base_manifest_java",
]
# For Trichrome, the primary abi arcore library is added to
# TrichromeLibrary.apk, so it's not needed here.
if (!_is_trichrome) {
_arcore_target = "//third_party/arcore-android-sdk-client:com_google_ar_core_J__unpack_aar"
deps += [ _arcore_target ]
_libarcore_dir = get_label_info(_arcore_target, "target_out_dir") +
"/com_google_ar_core_java/jni"
if (android_64bit_target_cpu) {
if (_is_64_bit_browser) {
loadable_modules +=
[ "$_libarcore_dir/arm64-v8a/libarcore_sdk_c.so" ]
} else {
secondary_abi_loadable_modules +=
[ "$_libarcore_dir/armeabi-v7a/libarcore_sdk_c.so" ]
}
} else {
loadable_modules +=
[ "$_libarcore_dir/armeabi-v7a/libarcore_sdk_c.so" ]
}
}
}
library_always_compress = []
if (defined(invoker.library_always_compress)) {
library_always_compress = invoker.library_always_compress
}
# TODO(agrieve): Use Crashpad trampoline in chrome_public_apk.
if (!_is_monochrome && !_is_trichrome) {
deps +=
[ "//components/crash/core/app:chrome_crashpad_handler_named_as_so" ]
loadable_modules += [ "$root_out_dir/libchrome_crashpad_handler.so" ]
library_always_compress += [ "libchrome_crashpad_handler.so" ]
} else if (!_is_trichrome) {
# Crashpad trampoline lives in TrichromeLibrary.apk.
# https://chromium.googlesource.com/chromium/src/+/main/docs/android_native_libraries.md#Crashpad-Packaging
if (_include_primary_abi) {
deps += [
"//third_party/crashpad/crashpad/handler:crashpad_handler_trampoline",
]
loadable_modules +=
[ "$root_out_dir/libcrashpad_handler_trampoline.so" ]
}
if (_include_secondary_abi) {
deps += [ "//third_party/crashpad/crashpad/handler:crashpad_handler_trampoline($android_secondary_abi_toolchain)" ]
secondary_abi_loadable_modules +=
[ "$_secondary_out_dir/libcrashpad_handler_trampoline.so" ]
}
}
# The Chromium Linker depends on ASharedMemory_create() introduced in O.
use_chromium_linker = chromium_linker_supported && _is_trichrome
if (use_chromium_linker) {
if (android_64bit_target_cpu && !_is_64_bit_browser) {
deps += [ "//base/android/linker:chromium_android_linker($android_secondary_abi_toolchain)" ]
secondary_abi_loadable_modules +=
[ "$_secondary_out_dir/libchromium_android_linker$shlib_extension" ]
} else {
deps += [ "//base/android/linker:chromium_android_linker" ]
loadable_modules +=
[ "$root_out_dir/libchromium_android_linker$shlib_extension" ]
}
if (_is_64_bit_browser && build_hwasan_splits) {
deps += [
"//base/android/linker:chromium_android_linker($_hwasan_toolchain)",
]
_hwasan_outdir = get_label_info(":($_hwasan_toolchain)", "root_out_dir")
loadable_modules +=
[ "$_hwasan_outdir/libchromium_android_linker$shlib_extension" ]
}
}
if (_is_trichrome) {
if (android_64bit_target_cpu && !_is_64_bit_browser) {
static_library_provider_use_secondary_abi = true
}
# Include placeholder libraries to make Chrome multiarch in the same way
# as Monochrome, even though Chrome only runs with one of the two
# bitnesses. This allows the "32-bit" and "64-bit" versions of Chrome to
# depend on their respective versions of the shared library APK even
# though they're functionally the same.
if (_include_primary_abi && loadable_modules == []) {
native_lib_placeholders = [ "libplaceholder.so" ]
}
if (_include_secondary_abi && secondary_abi_loadable_modules == []) {
secondary_native_lib_placeholders = [ "libplaceholder.so" ]
}
}
if (_is_test) {
bundles_supported = true
deps += [ "//third_party/androidx:androidx_test_runner_java" ]
# For EmbeddedTestServer.
additional_apks = [ "//net/android:net_test_support_apk" ]
if (defined(invoker.additional_apks)) {
additional_apks += invoker.additional_apks
}
}
forward_variables_from(invoker,
"*",
TESTONLY_AND_VISIBILITY + [
"additional_apks",
"assert_no_deps",
"data_deps",
"deps",
"loadable_modules",
"manifest_package",
"proguard_configs",
"resources_config_paths",
"secondary_abi_loadable_modules",
"secondary_abi_shared_libraries",
"shared_libraries",
"srcjar_deps",
"version_code",
"version_name",
])
}
}
# For creating chrome targets without internal customizations.
template("chrome_public_apk_or_module_tmpl") {
chrome_common_apk_or_module_tmpl(target_name) {
add_upstream_only_deps = true
forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
forward_variables_from(invoker, "*", TESTONLY_AND_VISIBILITY)
}
}
template("chrome_public_test_apk_tmpl") {
chrome_common_apk_or_module_tmpl(target_name) {
add_upstream_only_deps = true
target_type = "instrumentation_test_apk"
forward_variables_from(invoker, TESTONLY_AND_VISIBILITY)
forward_variables_from(invoker, "*", TESTONLY_AND_VISIBILITY)
}
}
Codebase Browser
chromium