#!/usr/bin/env python3
# Copyright (C) 2022 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# This tool translates a collection of BUILD.gn files into a mostly equivalent
# Android.bp file for the Android Soong build system. The input to the tool is a
# JSON description of the GN build definition generated with the following
# command:
#
# gn desc out --format=json --all-toolchains "//*" > desc.json
#
# The tool is then given a list of GN labels for which to generate Android.bp
# build rules. The dependencies for the GN labels are squashed to the generated
# Android.bp target, except for actions which get their own genrule. Some
# libraries are also mapped to their Android equivalents -- see |builtin_deps|.
import argparse
import json
import logging as log
import operator
import os
import re
import sys
import copy
from pathlib import Path
import gn_utils
ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
CRONET_LICENSE_NAME = "external_cronet_license"
# Default targets to translate to the blueprint file.
DEFAULT_TARGETS = [
"//components/cronet/android:cronet_api_java",
'//components/cronet/android:cronet',
'//components/cronet/android:cronet_impl_native_java',
'//components/cronet/android:cronet_jni_registration_java',
]
DEFAULT_TESTS = [
'//components/cronet/android:cronet_unittests_android__library',
'//net:net_unittests__library',
'//components/cronet/android:cronet_tests',
'//components/cronet/android:cronet',
'//components/cronet/android:cronet_javatests',
'//components/cronet/android:cronet_jni_registration_java',
'//components/cronet/android:cronet_tests_jni_registration_java',
'//testing/android/native_test:native_test_java',
'//net/android:net_test_support_provider_java',
'//net/android:net_tests_java',
'//third_party/netty-tcnative:netty-tcnative-so',
'//third_party/netty4:netty_all_java',
]
EXTRAS_ANDROID_BP_FILE = "Android.extras.bp"
CRONET_API_MODULE_NAME = "cronet_aml_api_java"
# All module names are prefixed with this string to avoid collisions.
module_prefix = 'cronet_aml_'
REMOVE_GEN_JNI_JARJAR_RULES_FILE = "android/tools/remove-gen-jni-jarjar-rules.txt"
# Shared libraries which are directly translated to Android system equivalents.
shared_library_allowlist = [
'android',
'log',
]
# Include directories that will be removed from all targets.
local_include_dirs_denylist = [
'third_party/zlib/',
]
# Name of the module which settings such as compiler flags for all other
# modules.
defaults_module = module_prefix + 'defaults'
# Location of the project in the Android source tree.
tree_path = 'external/cronet'
# Path for the protobuf sources in the standalone build.
buildtools_protobuf_src = '//buildtools/protobuf/src'
# Location of the protobuf src dir in the Android source tree.
android_protobuf_src = 'external/protobuf/src'
# put all args on a new line for better diffs.
NEWLINE = ' " +\n "'
# Compiler flags which are passed through to the blueprint.
cflag_allowlist = [
# needed for zlib:zlib
"-mpclmul",
# needed for zlib:zlib
"-mssse3",
# needed for zlib:zlib
"-msse3",
# needed for zlib:zlib
"-msse4.2",
# flags to reduce binary size
"-O1",
"-O2",
"-O3",
"-Oz",
"-g1",
"-g2",
"-fdata-sections",
"-ffunction-sections",
"-fvisibility=hidden",
"-fvisibility-inlines-hidden",
"-fstack-protector",
"-mno-outline",
"-mno-outline-atomics",
"-fno-asynchronous-unwind-tables",
"-fno-unwind-tables",
]
# Linker flags which are passed through to the blueprint.
ldflag_allowlist = [
# flags to reduce binary size
"-Wl,--as-needed",
"-Wl,--gc-sections",
"-Wl,--icf=all",
]
def get_linker_script_ldflag(script_path):
return f'-Wl,--script,{tree_path}/{script_path}'
# Additional arguments to apply to Android.bp rules.
additional_args = {
'cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers':
[('export_include_dirs', {
"net/third_party/quiche/src",
})],
'cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen__testing_headers':
[('export_include_dirs', {
"net/third_party/quiche/src",
})],
'cronet_aml_third_party_quic_trace_quic_trace_proto_gen__testing_headers':
[('export_include_dirs', {
"third_party/quic_trace/src",
})],
# TODO: fix upstream. Both //base:base and
# //base/allocator/partition_allocator:partition_alloc do not create a
# dependency on gtest despite using gtest_prod.h.
'cronet_aml_base_base': [
('header_libs', {
'libgtest_prod_headers',
}),
('export_header_lib_headers', {
'libgtest_prod_headers',
}),
],
'cronet_aml_base_allocator_partition_allocator_partition_alloc': [
('header_libs', {
'libgtest_prod_headers',
}),
],
# TODO(b/309920629): Remove once upstreamed.
'cronet_aml_components_cronet_android_cronet_api_java': [
('srcs', {
'components/cronet/android/api/src/org/chromium/net/UploadDataProviders.java',
'components/cronet/android/api/src/org/chromium/net/apihelpers/UploadDataProviders.java',
}),
],
'cronet_aml_components_cronet_android_cronet_api_java__testing': [
('srcs', {
'components/cronet/android/api/src/org/chromium/net/UploadDataProviders.java',
'components/cronet/android/api/src/org/chromium/net/apihelpers/UploadDataProviders.java',
}),
],
'cronet_aml_components_cronet_android_cronet_javatests__testing': [
# Needed to @SkipPresubmit annotations
('static_libs', {
'net-tests-utils',
}),
# This is necessary because net-tests-utils compiles against private SDK.
('sdk_version', ""),
],
'cronet_aml_testing_android_native_test_native_test_java__testing': [
('srcs', {
'testing/android/native_test/java/src/org/chromium/native_test/SignalMaskInfo.java',
}),
],
'cronet_aml_components_cronet_android_cronet__testing': [
('target', ('android_riscv64', {
'stem': "libmainlinecronet_riscv64"
})),
('comment', """TODO: remove stem for riscv64
// This is essential as there can't be two different modules
// with the same output. We usually got away with that because
// the non-testing Cronet is part of the Tethering APEX and the
// testing Cronet is not part of the Tethering APEX which made them
// look like two different outputs from the build system perspective.
// However, Cronet does not ship to Tethering APEX for RISCV64 which
// raises the conflict. Once we start shipping Cronet for RISCV64,
// this can be removed."""),
],
'cronet_aml_third_party_netty_tcnative_netty_tcnative_so__testing':
[('cflags', {"-Wno-error=pointer-bool-conversion"})],
'cronet_aml_third_party_apache_portable_runtime_apr__testing': [
('cflags', {
"-Wno-incompatible-pointer-types-discards-qualifiers",
})
],
# TODO(b/324872305): Remove when gn desc expands public_configs and update code to propagate the
# include_dir from the public_configs
# We had to add the export_include_dirs for each target because soong generates each header
# file in a specific directory named after the target.
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_chromecast_buildflags':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_chromecast_buildflags__testing':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_chromeos_buildflags':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_chromeos_buildflags__testing':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_debugging_buildflags':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_debugging_buildflags__testing':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_partition_alloc_buildflags':
[('export_include_dirs', {
".",
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_partition_alloc_buildflags__testing':
[('export_include_dirs', {
".",
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_raw_ptr_buildflags':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
'cronet_aml_base_allocator_partition_allocator_src_partition_alloc_raw_ptr_buildflags__testing':
[('export_include_dirs', {
"base/allocator/partition_allocator/src/",
})],
# end export_include_dir.
}
def always_disable(module, arch):
return None
def enable_zlib(module, arch):
# Requires crrev/c/4109079
if arch == 'common':
module.shared_libs.add('libz')
else:
module.target[arch].shared_libs.add('libz')
def enable_boringssl(module, arch):
# Do not add boringssl targets to cc_genrules. This happens, because protobuf targets are
# originally static_libraries, but later get converted to a cc_genrule.
if module.is_genrule(): return
# Lets keep statically linking BoringSSL for testing target for now. This should be fixed.
if module.name.endswith(gn_utils.TESTING_SUFFIX): return
if arch == 'common':
shared_libs = module.shared_libs
else:
shared_libs = module.target[arch].shared_libs
shared_libs.add('//external/cronet/third_party/boringssl:libcrypto')
shared_libs.add('//external/cronet/third_party/boringssl:libssl')
shared_libs.add('//external/cronet/third_party/boringssl:libpki')
def add_androidx_experimental_java_deps(module, arch):
module.libs.add("androidx.annotation_annotation-experimental")
def add_androidx_annotation_java_deps(module, arch):
module.libs.add("androidx.annotation_annotation")
def add_protobuf_lite_runtime_java_deps(module, arch):
module.static_libs.add("libprotobuf-java-lite")
def add_androidx_core_java_deps(module, arch):
module.libs.add("androidx.core_core")
def add_jsr305_java_deps(module, arch):
module.libs.add("jsr305")
def add_errorprone_annotation_java_deps(module, arch):
module.libs.add("error_prone_annotations")
def add_androidx_collection_java_deps(module, arch):
module.libs.add("androidx.collection_collection")
def add_junit_java_deps(module, arch):
module.static_libs.add("junit")
def add_truth_java_deps(module, arch):
module.static_libs.add("truth")
def add_hamcrest_java_deps(module, arch):
module.static_libs.add("hamcrest-library")
module.static_libs.add("hamcrest")
def add_mockito_java_deps(module, arch):
module.static_libs.add("mockito")
def add_guava_java_deps(module, arch):
module.static_libs.add("guava")
def add_androidx_junit_java_deps(module, arch):
module.static_libs.add("androidx.test.ext.junit")
def add_androidx_test_runner_java_deps(module, arch):
module.static_libs.add("androidx.test.runner")
def add_androidx_test_rules_java_deps(module, arch):
module.static_libs.add("androidx.test.rules")
def add_android_test_base_java_deps(module, arch):
module.libs.add("android.test.base")
def add_accessibility_test_framework_java_deps(module, arch):
module.static_libs.add("accessibility-test-framework")
def add_espresso_java_deps(module, arch):
module.static_libs.add("androidx.test.espresso.contrib")
def add_android_test_mock_java_deps(module, arch):
module.libs.add("android.test.mock")
def add_androidx_multidex_java_deps(module, arch):
# Androidx-multidex is disabled on unbundled branches.
pass
def add_androidx_test_monitor_java_deps(module, arch):
module.libs.add("androidx.test.monitor")
def add_androidx_ui_automator_java_deps(module, arch):
module.static_libs.add("androidx.test.uiautomator_uiautomator")
def add_androidx_test_annotation_java_deps(module, arch):
module.static_libs.add("androidx.test.rules")
def add_androidx_test_core_java_deps(module, arch):
module.static_libs.add("androidx.test.core")
def add_androidx_activity_activity(module, arch):
module.static_libs.add("androidx.activity_activity")
def add_androidx_fragment_fragment(module, arch):
module.static_libs.add("androidx.fragment_fragment")
# Android equivalents for third-party libraries that the upstream project
# depends on. This will be applied to normal and testing targets.
_builtin_deps = {
'//buildtools/third_party/libunwind:libunwind':
always_disable,
'//net/data/ssl/chrome_root_store:gen_root_store_inc':
always_disable,
'//net/tools/root_store_tool:root_store_tool':
always_disable,
'//third_party/zlib:zlib':
enable_zlib,
'//third_party/androidx:androidx_annotation_annotation_java':
add_androidx_annotation_java_deps,
'//third_party/android_deps:protobuf_lite_runtime_java':
add_protobuf_lite_runtime_java_deps,
'//third_party/androidx:androidx_annotation_annotation_experimental_java':
add_androidx_experimental_java_deps,
'//third_party/androidx:androidx_core_core_java':
add_androidx_core_java_deps,
'//third_party/android_deps:com_google_code_findbugs_jsr305_java':
add_jsr305_java_deps,
'//third_party/android_deps:com_google_errorprone_error_prone_annotations_java':
add_errorprone_annotation_java_deps,
'//third_party/androidx:androidx_collection_collection_java':
add_androidx_collection_java_deps,
'//third_party/junit:junit':
add_junit_java_deps,
'//third_party/google-truth:google_truth_java':
add_truth_java_deps,
'//third_party/hamcrest:hamcrest_core_java':
add_hamcrest_java_deps,
'//third_party/mockito:mockito_java':
add_mockito_java_deps,
'//third_party/android_deps:guava_android_java':
add_guava_java_deps,
'//third_party/androidx:androidx_test_ext_junit_java':
add_androidx_junit_java_deps,
'//third_party/androidx:androidx_test_runner_java':
add_androidx_test_runner_java_deps,
'//third_party/android_sdk:android_test_base_java':
add_android_test_base_java_deps,
'//third_party/accessibility_test_framework:accessibility_test_framework_java':
add_accessibility_test_framework_java_deps,
'//third_party/accessibility_test_framework:accessibility_core_java':
add_accessibility_test_framework_java_deps,
'//third_party/android_deps:espresso_java':
add_espresso_java_deps,
'//third_party/android_sdk:android_test_mock_java':
add_android_test_mock_java_deps,
'//third_party/androidx:androidx_multidex_multidex_java':
add_androidx_multidex_java_deps,
'//third_party/androidx:androidx_test_monitor_java':
add_androidx_test_monitor_java_deps,
'//third_party/androidx:androidx_test_annotation_java':
add_androidx_test_annotation_java_deps,
'//third_party/androidx:androidx_test_core_java':
add_androidx_test_core_java_deps,
'//third_party/androidx:androidx_test_uiautomator_uiautomator_java':
add_androidx_ui_automator_java_deps,
'//third_party/hamcrest:hamcrest_java':
add_hamcrest_java_deps,
'//third_party/androidx:androidx_activity_activity_java':
add_androidx_activity_activity,
'//third_party/androidx:androidx_fragment_fragment_java':
add_androidx_fragment_fragment,
'//third_party/androidx:androidx_test_rules_java':
add_androidx_test_rules_java_deps,
}
builtin_deps = {
"{}{}".format(key, suffix): value
for key, value in _builtin_deps.items()
for suffix in ["", gn_utils.TESTING_SUFFIX]
}
# Same as _builtin_deps but will only apply what is explicitly specified.
builtin_deps.update({
'//third_party/boringssl:boringssl': enable_boringssl,
'//third_party/boringssl:boringssl_asm':
# Due to FIPS requirements, downstream BoringSSL has a different "shape" than upstream's.
# We're guaranteed that if X depends on :boringssl it will also depend on :boringssl_asm.
# Hence, always drop :boringssl_asm and handle the translation entirely in :boringssl.
always_disable,
})
# Name of tethering apex module
tethering_apex = "com.android.tethering"
# Name of cronet api target
java_api_target_name = "//components/cronet/android:cronet_api_java"
# Visibility set for package default
package_default_visibility = ":__subpackages__"
# Visibility set for modules used from Connectivity and within external/cronet
root_modules_visibility = {
"//packages/modules/Connectivity:__subpackages__",
"//external/cronet:__subpackages__"
}
# ----------------------------------------------------------------------------
# End of configuration.
# ----------------------------------------------------------------------------
def write_blueprint_key_value(output, name, value, sort=True):
"""Writes a Blueprint key-value pair to the output"""
if isinstance(value, bool):
if value:
output.append(' %s: true,' % name)
else:
output.append(' %s: false,' % name)
return
if not value:
return
if isinstance(value, set):
value = sorted(value)
if isinstance(value, list):
output.append(' %s: [' % name)
for item in sorted(value) if sort else value:
output.append(' "%s",' % item)
output.append(' ],')
return
if isinstance(value, Module.Target):
value.to_string(output)
return
if isinstance(value, dict):
kv_output = []
for k, v in value.items():
write_blueprint_key_value(kv_output, k, v)
output.append(' %s: {' % name)
for line in kv_output:
output.append(' %s' % line)
output.append(' },')
return
output.append(' %s: "%s",' % (name, value))
class Module(object):
"""A single module (e.g., cc_binary, cc_test) in a blueprint."""
class Target(object):
"""A target-scoped part of a module"""
def __init__(self, name):
self.name = name
self.srcs = set()
self.shared_libs = set()
self.static_libs = set()
self.whole_static_libs = set()
self.header_libs = set()
self.cflags = set()
self.stl = None
self.cppflags = set()
self.local_include_dirs = set()
self.generated_headers = set()
self.export_generated_headers = set()
self.ldflags = set()
self.compile_multilib = None
self.stem = ""
if name == 'host':
self.compile_multilib = '64'
def to_string(self, output):
nested_out = []
self._output_field(nested_out, 'srcs')
self._output_field(nested_out, 'shared_libs')
self._output_field(nested_out, 'static_libs')
self._output_field(nested_out, 'whole_static_libs')
self._output_field(nested_out, 'header_libs')
self._output_field(nested_out, 'cflags')
self._output_field(nested_out, 'stl')
self._output_field(nested_out, 'cppflags')
self._output_field(nested_out, 'local_include_dirs')
self._output_field(nested_out, 'generated_headers')
self._output_field(nested_out, 'export_generated_headers')
self._output_field(nested_out, 'ldflags')
self._output_field(nested_out, 'stem')
if nested_out:
# This is added here to make sure it doesn't add a `host` arch-specific module just for
# `compile_multilib` flag.
self._output_field(nested_out, 'compile_multilib')
output.append(' %s: {' % self.name)
for line in nested_out:
output.append(' %s' % line)
output.append(' },')
def _output_field(self, output, name, sort=True):
value = getattr(self, name)
return write_blueprint_key_value(output, name, value, sort)
def __init__(self, mod_type, name, gn_target):
self.type = mod_type
self.gn_target = gn_target
self.name = name
self.srcs = set()
self.comment = 'GN: ' + gn_target
self.shared_libs = set()
self.static_libs = set()
self.whole_static_libs = set()
self.tools = set()
self.cmd = None
self.host_supported = False
self.device_supported = True
self.init_rc = set()
self.out = set()
self.export_include_dirs = set()
self.generated_headers = set()
self.export_generated_headers = set()
self.export_static_lib_headers = set()
self.export_header_lib_headers = set()
self.defaults = set()
self.cflags = set()
self.include_dirs = set()
self.local_include_dirs = set()
self.header_libs = set()
self.tool_files = set()
# target contains a dict of Targets indexed by os_arch.
# example: { 'android_x86': Target('android_x86')
self.target = dict()
self.target['android'] = self.Target('android')
self.target['android_x86'] = self.Target('android_x86')
self.target['android_x86_64'] = self.Target('android_x86_64')
self.target['android_arm'] = self.Target('android_arm')
self.target['android_arm64'] = self.Target('android_arm64')
self.target['android_riscv64'] = self.Target('android_riscv64')
self.target['host'] = self.Target('host')
self.target['glibc'] = self.Target('glibc')
self.stl = None
self.cpp_std = None
self.strip = dict()
self.data = set()
self.apex_available = set()
self.min_sdk_version = None
self.proto = dict()
self.linker_scripts = set()
self.ldflags = set()
# The genrule_XXX below are properties that must to be propagated back
# on the module(s) that depend on the genrule.
self.genrule_headers = set()
self.genrule_srcs = set()
self.genrule_shared_libs = set()
self.genrule_header_libs = set()
self.version_script = None
self.test_suites = set()
self.test_config = None
self.cppflags = set()
self.rtti = False
# Name of the output. Used for setting .so file name for libcronet
self.libs = set()
self.stem = None
self.compile_multilib = None
self.aidl = dict()
self.plugins = set()
self.processor_class = None
self.sdk_version = None
self.javacflags = set()
self.c_std = None
self.default_applicable_licenses = set()
self.default_visibility = []
self.visibility = set()
self.gn_type = None
self.jarjar_rules = ""
self.jars = set()
def to_string(self, output):
if self.comment:
output.append('// %s' % self.comment)
output.append('%s {' % self.type)
self._output_field(output, 'name')
self._output_field(output, 'srcs')
self._output_field(output, 'shared_libs')
self._output_field(output, 'static_libs')
self._output_field(output, 'whole_static_libs')
self._output_field(output, 'tools')
self._output_field(output, 'cmd', sort=False)
if self.host_supported:
self._output_field(output, 'host_supported')
if not self.device_supported:
self._output_field(output, 'device_supported')
self._output_field(output, 'init_rc')
self._output_field(output, 'out')
self._output_field(output, 'export_include_dirs')
self._output_field(output, 'generated_headers')
self._output_field(output, 'export_generated_headers')
self._output_field(output, 'export_static_lib_headers')
self._output_field(output, 'export_header_lib_headers')
self._output_field(output, 'defaults')
self._output_field(output, 'cflags')
self._output_field(output, 'include_dirs')
self._output_field(output, 'local_include_dirs')
self._output_field(output, 'header_libs')
self._output_field(output, 'strip')
self._output_field(output, 'tool_files')
self._output_field(output, 'data')
self._output_field(output, 'stl')
self._output_field(output, 'cpp_std')
self._output_field(output, 'apex_available')
self._output_field(output, 'min_sdk_version')
self._output_field(output, 'version_script')
self._output_field(output, 'test_suites')
self._output_field(output, 'test_config')
self._output_field(output, 'proto')
self._output_field(output, 'linker_scripts')
self._output_field(output, 'ldflags')
self._output_field(output, 'cppflags')
self._output_field(output, 'libs')
self._output_field(output, 'stem')
self._output_field(output, 'compile_multilib')
self._output_field(output, 'aidl')
self._output_field(output, 'plugins')
self._output_field(output, 'processor_class')
self._output_field(output, 'sdk_version')
self._output_field(output, 'javacflags')
self._output_field(output, 'c_std')
self._output_field(output, 'default_applicable_licenses')
self._output_field(output, 'default_visibility')
self._output_field(output, 'visibility')
self._output_field(output, 'jarjar_rules')
self._output_field(output, 'jars')
if self.rtti:
self._output_field(output, 'rtti')
target_out = []
for arch, target in sorted(self.target.items()):
# _output_field calls getattr(self, arch).
setattr(self, arch, target)
self._output_field(target_out, arch)
if target_out:
output.append(' target: {')
for line in target_out:
output.append(' %s' % line)
output.append(' },')
output.append('}')
output.append('')
def add_android_shared_lib(self, lib):
if self.type.startswith('java'):
raise Exception(
'Adding Android shared lib for java_* targets is unsupported')
elif self.type == 'cc_binary_host':
raise Exception(
'Adding Android shared lib for host tool is unsupported')
elif self.host_supported:
self.target['android'].shared_libs.add(lib)
else:
self.shared_libs.add(lib)
def is_test(self):
if gn_utils.TESTING_SUFFIX in self.name:
name_without_prefix = self.name[:self.name.find(gn_utils.
TESTING_SUFFIX)]
return any([
name_without_prefix == label_to_module_name(target)
for target in DEFAULT_TESTS
])
return False
def _output_field(self, output, name, sort=True):
value = getattr(self, name)
return write_blueprint_key_value(output, name, value, sort)
def is_compiled(self):
return self.type not in ('cc_genrule', 'filegroup', 'java_genrule')
def is_genrule(self):
return self.type == "cc_genrule"
def has_input_files(self):
if self.type in ["java_library", "java_import"]:
return True
if len(self.srcs) > 0:
return True
if any([len(target.srcs) > 0 for target in self.target.values()]):
return True
# Allow cc_static_library with export_generated_headers as those are crucial for
# the depending modules
return len(self.export_generated_headers) > 0
class Blueprint(object):
"""In-memory representation of an Android.bp file."""
def __init__(self):
self.modules = {}
def add_module(self, module):
"""Adds a new module to the blueprint, replacing any existing module
with the same name.
Args:
module: Module instance.
"""
self.modules[module.name] = module
def to_string(self, output):
for m in sorted(self.modules.values(), key=lambda m: m.name):
if m.type != "cc_library_static" or m.has_input_files():
# Don't print cc_library_static with empty srcs. These attributes are already
# propagated up the tree. Printing them messes the presubmits because
# every module is compiled while those targets are not reachable in
# a normal compilation path.
m.to_string(output)
def label_to_module_name(label):
"""Turn a GN label (e.g., //:perfetto_tests) into a module name."""
module = re.sub(r'^//:?', '', label)
module = re.sub(r'[^a-zA-Z0-9_]', '_', module)
if not module.startswith(module_prefix):
return module_prefix + module
return module
def is_supported_source_file(name):
"""Returns True if |name| can appear in a 'srcs' list."""
return os.path.splitext(name)[1] in [
'.c', '.cc', '.cpp', '.java', '.proto', '.S', '.aidl'
]
def get_protoc_module_name(gn):
protoc_gn_target_name = gn.get_target('//third_party/protobuf:protoc').name
return label_to_module_name(protoc_gn_target_name)
def create_proto_modules(blueprint, gn, target):
"""Generate genrules for a proto GN target.
GN actions are used to dynamically generate files during the build. The
Soong equivalent is a genrule. This function turns a specific kind of
genrule which turns .proto files into source and header files into a pair
equivalent genrules.
Args:
blueprint: Blueprint instance which is being generated.
target: gn_utils.Target object.
Returns:
The source_genrule module.
"""
assert (target.type == 'proto_library')
protoc_module_name = get_protoc_module_name(gn)
tools = {protoc_module_name}
cpp_out_dir = '$(genDir)/%s/%s/' % (tree_path, target.proto_in_dir)
target_module_name = label_to_module_name(target.name)
# In GN builds the proto path is always relative to the output directory
# (out/tmp.xxx).
cmd = ['$(location %s)' % protoc_module_name]
cmd += ['--proto_path=%s/%s' % (tree_path, target.proto_in_dir)]
for proto_path in target.proto_paths:
cmd += [f'--proto_path={tree_path}/{proto_path}']
if buildtools_protobuf_src in target.proto_paths:
cmd += ['--proto_path=%s' % android_protobuf_src]
# We don't generate any targets for source_set proto modules because
# they will be inlined into other modules if required.
if target.proto_plugin == 'source_set':
return None
# Descriptor targets only generate a single target.
if target.proto_plugin == 'descriptor':
out = '{}.bin'.format(target_module_name)
cmd += ['--descriptor_set_out=$(out)']
cmd += ['$(in)']
descriptor_module = Module('cc_genrule', target_module_name,
target.name)
descriptor_module.cmd = ' '.join(cmd)
descriptor_module.out = [out]
descriptor_module.tools = tools
blueprint.add_module(descriptor_module)
# Recursively extract the .proto files of all the dependencies and
# add them to srcs.
descriptor_module.srcs.update(
gn_utils.label_to_path(src) for src in target.sources)
for dep in target.proto_deps:
current_target = gn.get_target(dep)
descriptor_module.srcs.update(
gn_utils.label_to_path(src) for src in current_target.sources)
return descriptor_module
# We create two genrules for each proto target: one for the headers and
# another for the sources. This is because the module that depends on the
# generated files needs to declare two different types of dependencies --
# source files in 'srcs' and headers in 'generated_headers' -- and it's not
# valid to generate .h files from a source dependency and vice versa.
source_module_name = target_module_name
source_module = Module('cc_genrule', source_module_name, target.name)
blueprint.add_module(source_module)
source_module.srcs.update(
gn_utils.label_to_path(src) for src in target.sources)
header_module = Module('cc_genrule', source_module_name + '_headers',
target.name)
blueprint.add_module(header_module)
header_module.srcs = set(source_module.srcs)
# TODO(primiano): at some point we should remove this. This was introduced
# by aosp/1108421 when adding "protos/" to .proto include paths, in order to
# avoid doing multi-repo changes and allow old clients in the android tree
# to still do the old #include "perfetto/..." rather than
# #include "protos/perfetto/...".
header_module.export_include_dirs = {'.', 'protos'}
# Since the .cc file and .h get created by a different gerule target, they
# are not put in the same intermediate path, so local includes do not work
# without explictily exporting the include dir.
header_module.export_include_dirs.add(target.proto_in_dir)
# This function does not return header_module so setting apex_available attribute here.
header_module.apex_available.add(tethering_apex)
source_module.genrule_srcs.add(':' + source_module.name)
source_module.genrule_headers.add(header_module.name)
if target.proto_plugin == 'proto':
suffixes = ['pb']
source_module.genrule_shared_libs.add('libprotobuf-cpp-lite')
cmd += ['--cpp_out=lite=true:' + cpp_out_dir]
else:
raise Exception('Unsupported proto plugin: %s' % target.proto_plugin)
cmd += ['$(in)']
source_module.cmd = ' '.join(cmd)
header_module.cmd = source_module.cmd
source_module.tools = tools
header_module.tools = tools
for sfx in suffixes:
source_module.out.update(
'%s/%s' % (tree_path, src.replace('.proto', '.%s.cc' % sfx))
for src in source_module.srcs)
header_module.out.update(
'%s/%s' % (tree_path, src.replace('.proto', '.%s.h' % sfx))
for src in header_module.srcs)
# This has proto files that will be used for reference resolution
# but not compiled into cpp files. These additional sources has no output.
proto_data_sources = sorted([
gn_utils.label_to_path(proto_src) for proto_src in target.inputs
if proto_src.endswith(".proto")
])
source_module.srcs.update(proto_data_sources)
header_module.srcs.update(proto_data_sources)
return source_module
def create_gcc_preprocess_modules(blueprint, target):
# gcc_preprocess.py internally execute host gcc which is not allowed in genrule.
# So, this function create multiple modules and realize equivalent processing
# TODO: Consider to support gcc_preprocess.py in different way
# It's not great to have genrule and cc_object in the dependency from java_library
assert (len(target.sources) == 1)
source = list(target.sources)[0]
assert (Path(source).suffix == '.template')
stem = Path(source).stem
bp_module_name = label_to_module_name(target.name)
# Rename .template to .cc since cc_object does not accept .template file as srcs
rename_module = Module('genrule', bp_module_name + '_rename', target.name)
rename_module.srcs.add(gn_utils.label_to_path(source))
rename_module.out.add(stem + '.cc')
rename_module.cmd = 'cp $(in) $(out)'
blueprint.add_module(rename_module)
# Preprocess template file and generates java file
preprocess_module = Module('cc_object', bp_module_name + '_preprocess',
target.name)
# -E: stop after preprocessing.
# -P: disable line markers, i.e. '#line 309'
preprocess_module.cflags.update(['-E', '-P', '-DANDROID'])
preprocess_module.srcs.add(':' + rename_module.name)
defines = [
'-D' + target.args[i + 1] for i, arg in enumerate(target.args)
if arg == '--define'
]
preprocess_module.cflags.update(defines)
# HACK: Specifying compile_multilib to build cc_object only once.
# Without this, soong complain to genrule that depends on cc_object when built for 64bit target.
# It seems this is because cc object is a module with per-architecture variants and genrule is a
# module with default variant. For 64bit target, cc_object is built multiple times for 32/64bit
# modes and genrule doesn't know which one to depend on.
preprocess_module.compile_multilib = 'first'
blueprint.add_module(preprocess_module)
# Generates srcjar using soong_zip
module = Module('genrule', bp_module_name, target.name)
module.srcs.add(':' + preprocess_module.name)
module.out.add(stem + '.srcjar')
module.cmd = NEWLINE.join([
f'cp $(in) $(genDir)/{stem}.java &&',
f'$(location soong_zip) -o $(out) -srcjar -C $(genDir) -f $(genDir)/{stem}.java'
])
module.tools.add('soong_zip')
blueprint.add_module(module)
return module
class BaseActionSanitizer():
def __init__(self, target, arch):
# Just to be on the safe side, create a deep-copy.
self.target = copy.deepcopy(target)
if arch:
# Merge arch specific attributes
self.target.sources |= arch.sources
self.target.inputs |= arch.inputs
self.target.outputs |= arch.outputs
self.target.script = self.target.script or arch.script
self.target.args = self.target.args or arch.args
self.target.response_file_contents = \
self.target.response_file_contents or arch.response_file_contents
self.target.args = self._normalize_args()
def get_name(self):
return label_to_module_name(self.target.name)
def _normalize_args(self):
# Convert ['--param=value'] to ['--param', 'value'] for consistency.
# Escape quotations.
normalized_args = []
for arg in self.target.args:
arg = arg.replace('"', r'\"')
if arg.startswith('-'):
normalized_args.extend(arg.split('='))
else:
normalized_args.append(arg)
return normalized_args
# There are three types of args:
# - flags (--flag)
# - value args (--arg value)
# - list args (--arg value1 --arg value2)
# value args have exactly one arg value pair and list args have one or more arg value pairs.
# Note that the set of list args contains the set of value args.
# This is because list and value args are identical when the list args has only one arg value pair
# Some functions provide special implementations for each type, while others
# work on all of them.
def _has_arg(self, arg):
return arg in self.target.args
def _get_arg_indices(self, target_arg):
return [
i for i, arg in enumerate(self.target.args) if arg == target_arg
]
# Whether an arg value pair appears once or more times
def _is_list_arg(self, arg):
indices = self._get_arg_indices(arg)
return len(indices) > 0 and all(
[not self.target.args[i + 1].startswith('--') for i in indices])
def _update_list_arg(self, arg, func, throw_if_absent=True):
if self._should_fail_silently(arg, throw_if_absent):
return
assert (self._is_list_arg(arg))
indices = self._get_arg_indices(arg)
for i in indices:
self._set_arg_at(i + 1, func(self.target.args[i + 1]))
# Whether an arg value pair appears exactly once
def _is_value_arg(self, arg):
return operator.countOf(self.target.args,
arg) == 1 and self._is_list_arg(arg)
def _get_value_arg(self, arg):
assert (self._is_value_arg(arg))
i = self.target.args.index(arg)
return self.target.args[i + 1]
# used to check whether a function call should cause an error when an arg is
# missing.
def _should_fail_silently(self, arg, throw_if_absent):
return not throw_if_absent and not self._has_arg(arg)
def _set_value_arg(self, arg, value, throw_if_absent=True):
if self._should_fail_silently(arg, throw_if_absent):
return
assert (self._is_value_arg(arg))
i = self.target.args.index(arg)
self.target.args[i + 1] = value
def _update_value_arg(self, arg, func, throw_if_absent=True):
if self._should_fail_silently(arg, throw_if_absent):
return
self._set_value_arg(arg, func(self._get_value_arg(arg)))
def _set_arg_at(self, position, value):
self.target.args[position] = value
def _update_arg_at(self, position, func):
self.target.args[position] = func(self.target.args[position])
def _delete_value_arg(self, arg, throw_if_absent=True):
if self._should_fail_silently(arg, throw_if_absent):
return
assert (self._is_value_arg(arg))
i = self.target.args.index(arg)
self.target.args.pop(i)
self.target.args.pop(i)
def _append_arg(self, arg, value):
self.target.args.append(arg)
self.target.args.append(value)
def _sanitize_filepath_with_location_tag(self, arg):
if arg.startswith('../../'):
arg = self._sanitize_filepath(arg)
arg = self._add_location_tag(arg)
return arg
# wrap filename in location tag.
def _add_location_tag(self, filename):
return '$(location %s)' % filename
# applies common directory transformation that *should* be universally applicable.
# TODO: verify if it actually *is* universally applicable.
def _sanitize_filepath(self, filepath):
# Careful, order matters!
# delete all leading ../
filepath = re.sub('^(\.\./)+', '', filepath)
filepath = re.sub('^gen/jni_headers', '$(genDir)', filepath)
filepath = re.sub('^gen', '$(genDir)', filepath)
return filepath
# Iterate through all the args and apply function
def _update_all_args(self, func):
self.target.args = [func(arg) for arg in self.target.args]
def get_pre_cmd(self):
pre_cmd = []
out_dirs = [
out[:out.rfind("/")] for out in self.target.outputs if "/" in out
]
# Sort the list to make the output deterministic.
for out_dir in sorted(set(out_dirs)):
pre_cmd.append("mkdir -p $(genDir)/{} && ".format(out_dir))
return NEWLINE.join(pre_cmd)
def get_base_cmd(self):
arg_string = NEWLINE.join(self.target.args)
cmd = '$(location %s) %s' % (gn_utils.label_to_path(
self.target.script), arg_string)
if self.use_response_file:
# Pipe response file contents into script
cmd = 'echo \'%s\' |%s%s' % (self.target.response_file_contents,
NEWLINE, cmd)
return cmd
def get_cmd(self):
return self.get_pre_cmd() + self.get_base_cmd()
def get_outputs(self):
return self.target.outputs
def get_srcs(self):
# gn treats inputs and sources for actions equally.
# soong only supports source files inside srcs, non-source files are added as
# tool_files dependency.
files = self.target.sources.union(self.target.inputs)
return {
gn_utils.label_to_path(file)
for file in files if is_supported_source_file(file)
}
def get_tools(self):
return set()
def get_tool_files(self):
# gn treats inputs and sources for actions equally.
# soong only supports source files inside srcs, non-source files are added as
# tool_files dependency.
files = self.target.sources.union(self.target.inputs)
tool_files = {
gn_utils.label_to_path(file)
for file in files
if not is_supported_source_file(file)
and not file.startswith("//out/")
}
tool_files.add(gn_utils.label_to_path(self.target.script))
return tool_files
def _sanitize_args(self):
# Handle passing parameters via response file by piping them into the script
# and reading them from /dev/stdin.
self.use_response_file = gn_utils.RESPONSE_FILE in self.target.args
if self.use_response_file:
# Replace {{response_file_contents}} with /dev/stdin
self.target.args = [
'/dev/stdin' if it == gn_utils.RESPONSE_FILE else it
for it in self.target.args
]
def _sanitize_inputs(self):
pass
def get_deps(self):
return self.target.deps
def sanitize(self):
self._sanitize_args()
self._sanitize_inputs()
# Whether this target generates header files
def is_header_generated(self):
return any(
os.path.splitext(it)[1] == '.h' for it in self.target.outputs)
class WriteBuildDateHeaderSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._set_arg_at(0, '$(out)')
self._set_arg_at(1, '`date +%s`')
super()._sanitize_args()
class WriteBuildFlagHeaderSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._set_value_arg('--gen-dir', '.')
self._set_value_arg('--output', '$(out)')
super()._sanitize_args()
class GnRunBinarySanitizer(BaseActionSanitizer):
def __init__(self, target, arch):
super().__init__(target, arch)
self.binary_to_target = {
"clang_x64/transport_security_state_generator":
"cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing",
}
self.binary = self.binary_to_target[self.target.args[0]]
def _replace_gen_with_location_tag(self, arg):
if arg.startswith("gen/"):
return "$(location %s)" % arg.replace("gen/", "")
return arg
def _replace_binary(self, arg):
if arg in self.binary_to_target:
return '$(location %s)' % self.binary
return arg
def _remove_python_args(self):
self.target.args = [
arg for arg in self.target.args if "python3" not in arg
]
def _sanitize_args(self):
self._update_all_args(self._sanitize_filepath_with_location_tag)
self._update_all_args(self._replace_gen_with_location_tag)
self._update_all_args(self._replace_binary)
self._remove_python_args()
super()._sanitize_args()
def get_tools(self):
tools = super().get_tools()
tools.add(self.binary)
return tools
def get_cmd(self):
# Remove the script and use the binary right away
return self.get_pre_cmd() + NEWLINE.join(self.target.args)
class JniGeneratorSanitizer(BaseActionSanitizer):
def __init__(self, target, arch, is_test_target):
self.is_test_target = is_test_target
super().__init__(target, arch)
def get_srcs(self):
all_srcs = super().get_srcs()
all_srcs.update({
gn_utils.label_to_path(file)
for file in self.target.transitive_jni_java_sources
if is_supported_source_file(file)
})
return set(src for src in all_srcs if src.endswith(".java"))
def _add_location_tag_to_filepath(self, arg):
if not arg.endswith('.class'):
# --input_file supports both .class specifiers or source files as arguments.
# Only source files need to be wrapped inside a $(location <label>) tag.
arg = self._add_location_tag(arg)
return arg
def _sanitize_args(self):
self._set_value_arg('--jar-file', '$(location :current_android_jar)',
False)
if self._has_arg('--jar-file'):
self._set_value_arg('--javap', '$(location :javap)')
self._update_value_arg('--srcjar-path', self._sanitize_filepath, False)
self._update_value_arg('--output-dir', self._sanitize_filepath)
self._update_value_arg('--extra-include', self._sanitize_filepath,
False)
self._update_list_arg('--input-file', self._sanitize_filepath)
self._update_list_arg('--input-file',
self._add_location_tag_to_filepath)
if not self.is_test_target and not self._has_arg('--jar-file'):
# Don't jarjar classes that already exists within the java SDK. The headers generated
# from those genrule can simply call into the original class as it exists outside
# of cronet's jar.
# Only jarjar platform code
self._append_arg('--package-prefix', 'android.net.connectivity')
super()._sanitize_args()
def get_outputs(self):
# fix target.output directory to match #include statements.
return {
re.sub('^jni_headers/', '', out)
for out in super().get_outputs()
}
def get_tool_files(self):
tool_files = super().get_tool_files()
# Filter android.jar and add :current_android_jar
tool_files = {
file
if not file.endswith('android.jar') else ':current_android_jar'
for file in tool_files
}
# Filter bin/javap
tool_files = {
file
for file in tool_files if not file.endswith('bin/javap')
}
return tool_files
def get_tools(self):
tools = super().get_tools()
if self._has_arg('--jar-file'):
tools.add(":javap")
return tools
class JavaJniGeneratorSanitizer(JniGeneratorSanitizer):
def __init__(self, target, arch, is_test_target):
self.is_test_target = is_test_target
super().__init__(target, arch, is_test_target)
def get_outputs(self):
# fix target.output directory to match #include statements.
outputs = {
re.sub('^jni_headers/', '', out)
for out in super().get_outputs()
}
self.target.outputs = [
out for out in outputs if out.endswith(".srcjar")
]
return outputs
def get_deps(self):
return {}
def get_name(self):
name = super().get_name() + "__java"
return name
class JniRegistrationGeneratorSanitizer(BaseActionSanitizer):
def __init__(self, target, arch, is_test_target):
self.is_test_target = is_test_target
super().__init__(target, arch)
def get_srcs(self):
all_srcs = super().get_srcs()
all_srcs.update({
gn_utils.label_to_path(file)
for file in self.target.transitive_jni_java_sources
if is_supported_source_file(file)
})
return set(src for src in all_srcs if src.endswith(".java"))
def _sanitize_inputs(self):
self.target.inputs = [
file for file in self.target.inputs
if not file.startswith('//out/')
]
def get_outputs(self):
return {
re.sub('^jni_headers/', '', out)
for out in super().get_outputs()
}
def _sanitize_args(self):
self._update_value_arg('--depfile', self._sanitize_filepath)
self._update_value_arg('--srcjar-path', self._sanitize_filepath)
self._update_value_arg('--header-path', self._sanitize_filepath)
self._delete_value_arg('--depfile', False)
self._set_value_arg('--java-sources-file', '$(genDir)/java.sources')
if not self.is_test_target:
# Only jarjar platform code
self._append_arg('--package-prefix', 'android.net.connectivity')
super()._sanitize_args()
def get_cmd(self):
# jni_registration_generator.py doesn't work with python2
cmd = "python3 " + super().get_base_cmd()
# Path in the original sources file does not work in genrule.
# So creating sources file in cmd based on the srcs of this target.
# Adding ../$(current_dir)/ to the head because jni_registration_generator.py uses the files
# whose path startswith(..)
commands = [
"current_dir=`basename \\\`pwd\\\``;", "for f in $(in);", "do",
"echo \\\"../$$current_dir/$$f\\\" >> $(genDir)/java.sources;",
"done;", cmd
]
return self.get_pre_cmd() + NEWLINE.join(commands)
class JavaJniRegistrationGeneratorSanitizer(JniRegistrationGeneratorSanitizer):
def get_name(self):
name = super().get_name() + "__java"
return name
def get_outputs(self):
return [
out for out in super().get_outputs() if out.endswith(".srcjar")
]
def get_deps(self):
return {}
class VersionSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._set_value_arg('-o', '$(out)')
# args for the version.py contain file path without leading --arg key. So apply sanitize
# function for all the args.
self._update_all_args(self._sanitize_filepath_with_location_tag)
for (i, arg) in enumerate(self.target.args):
if arg == '-e':
self.target.args[i + 1] = "'%s'" % self.target.args[i + 1]
super()._sanitize_args()
def get_tool_files(self):
tool_files = super().get_tool_files()
# android_chrome_version.py is not specified in anywhere but version.py imports this file
tool_files.add('build/util/android_chrome_version.py')
return tool_files
class JavaCppEnumSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._update_all_args(self._sanitize_filepath_with_location_tag)
self._set_value_arg('--srcjar', '$(out)')
super()._sanitize_args()
class MakeDafsaSanitizer(BaseActionSanitizer):
def is_header_generated(self):
# This script generates .cc files but they are #included by other sources
# (e.g. registry_controlled_domain.cc)
return True
class JavaCppFeatureSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._update_all_args(self._sanitize_filepath_with_location_tag)
self._set_value_arg('--srcjar', '$(out)')
super()._sanitize_args()
class JavaCppStringSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._update_all_args(self._sanitize_filepath_with_location_tag)
self._set_value_arg('--srcjar', '$(out)')
super()._sanitize_args()
class WriteNativeLibrariesJavaSanitizer(BaseActionSanitizer):
def _sanitize_args(self):
self._set_value_arg('--output', '$(out)')
super()._sanitize_args()
class ProtocJavaSanitizer(BaseActionSanitizer):
def __init__(self, target, arch, gn):
super().__init__(target, arch)
self._protoc = get_protoc_module_name(gn)
def _sanitize_proto_path(self, arg):
arg = self._sanitize_filepath(arg)
return tree_path + '/' + arg
def _sanitize_args(self):
super()._sanitize_args()
self._delete_value_arg('--depfile')
self._set_value_arg('--protoc', '$(location %s)' % self._protoc)
self._update_value_arg('--proto-path', self._sanitize_proto_path)
self._set_value_arg('--srcjar', '$(out)')
self._update_arg_at(-1, self._sanitize_filepath_with_location_tag)
def get_tools(self):
tools = super().get_tools()
tools.add(self._protoc)
return tools
def get_action_sanitizer(gn, target, type, arch, is_test_target):
if target.script in [
"//build/write_buildflag_header.py",
"//base/allocator/partition_allocator/src/partition_alloc/write_buildflag_header.py"
]:
return WriteBuildFlagHeaderSanitizer(target, arch)
elif target.script == "//base/write_build_date_header.py":
return WriteBuildDateHeaderSanitizer(target, arch)
elif target.script == "//build/util/version.py":
return VersionSanitizer(target, arch)
elif target.script == "//build/android/gyp/java_cpp_enum.py":
return JavaCppEnumSanitizer(target, arch)
elif target.script == "//net/tools/dafsa/make_dafsa.py":
return MakeDafsaSanitizer(target, arch)
elif target.script == '//build/android/gyp/java_cpp_features.py':
return JavaCppFeatureSanitizer(target, arch)
elif target.script == '//build/android/gyp/java_cpp_strings.py':
return JavaCppStringSanitizer(target, arch)
elif target.script == '//build/android/gyp/write_native_libraries_java.py':
return WriteNativeLibrariesJavaSanitizer(target, arch)
elif target.script == '//build/gn_run_binary.py':
return GnRunBinarySanitizer(target, arch)
elif target.script == '//build/protoc_java.py':
return ProtocJavaSanitizer(target, arch, gn)
elif target.script == '//third_party/jni_zero/jni_zero.py':
if target.args[0] == 'generate-final':
if type == 'java_genrule':
# Fill up the sources of the target for JniRegistrationGenerator
# actions with all the java sources found under targets of type
# `generate_jni`. Note 1: Only do this for the java part in order to
# generate a complete GEN_JNI. The C++ part MUST only include java
# source files that are listed explicitly in `generate_jni` targets
# in the transitive dependency, this is handled inside the action
# sanitizer itself (See `get_srcs`). Adding java sources that are not
# listed to the C++ version of JniRegistrationGenerator will result
# in undefined symbols as the C++ part generates declarations that
# would have no definitions. Note 2: This is only done for the
# testing targets because their JniRegistration is not complete,
# Chromium generates Jni files for testing targets implicitly (See
# https://source.chromium.org/chromium/chromium/src/+/main:testing
# /test.gni;l=422;bpv=1;bpt=0;drc
# =02820c1b362c3a00f426d7c4eab18703d89cda03) to avoid having to
# replicate the same setup, just fill up the java JniRegistration
# with all java sources found under `generate_jni` targets and fill
# the C++ version with the exact files.
if is_test_target:
target.sources.update(gn.jni_java_sources)
return JavaJniRegistrationGeneratorSanitizer(
target, arch, is_test_target)
else:
return JniRegistrationGeneratorSanitizer(
target, arch, is_test_target)
else:
if type == 'cc_genrule':
return JniGeneratorSanitizer(target, arch, is_test_target)
else:
return JavaJniGeneratorSanitizer(target, arch, is_test_target)
else:
raise Exception('Unsupported action %s from %s' %
(target.script, target.name))
def create_action_foreach_modules(blueprint, gn, target, is_test_target):
""" The following assumes that rebase_path exists in the args.
The args of an action_foreach contains hints about which output files are generated
by which source files.
This is copied directly from the args
"gen/net/base/registry_controlled_domains/{{source_name_part}}-reversed-inc.cc"
So each source file will generate an output whose name is the {source_name-reversed-inc.cc}
"""
new_args = []
for i, src in enumerate(sorted(target.sources)):
# don't add script arg for the first source -- create_action_module
# already does this.
if i != 0:
new_args.append('&&')
new_args.append('python3 $(location %s)' %
gn_utils.label_to_path(target.script))
for arg in target.args:
if '{{source}}' in arg:
new_args.append('$(location %s)' %
(gn_utils.label_to_path(src)))
elif '{{source_name_part}}' in arg:
source_name_part = src.split("/")[-1] # Get the file name only
source_name_part = source_name_part.split(".")[
0] # Remove the extension (Ex: .cc)
file_name = arg.replace('{{source_name_part}}',
source_name_part).split("/")[-1]
# file_name represent the output file name. But we need the whole path
# This can be found from target.outputs.
for out in target.outputs:
if out.endswith(file_name):
new_args.append('$(location %s)' % out)
for file in (target.sources | target.inputs):
if file.endswith(file_name):
new_args.append('$(location %s)' %
gn_utils.label_to_path(file))
else:
new_args.append(arg)
target.args = new_args
return create_action_module(blueprint, gn, target, 'cc_genrule',
is_test_target)
def create_action_module_internal(gn,
target,
type,
is_test_target,
blueprint,
arch=None):
if target.script == '//build/android/gyp/gcc_preprocess.py':
return create_gcc_preprocess_modules(blueprint, target)
sanitizer = get_action_sanitizer(gn, target, type, arch, is_test_target)
sanitizer.sanitize()
module = Module(type, sanitizer.get_name(), target.name)
module.cmd = sanitizer.get_cmd()
module.out = sanitizer.get_outputs()
if sanitizer.is_header_generated():
module.genrule_headers.add(module.name)
module.srcs = sanitizer.get_srcs()
module.tool_files = sanitizer.get_tool_files()
module.tools = sanitizer.get_tools()
target.deps = sanitizer.get_deps()
return module
def get_cmd_condition(arch):
'''
:param arch: archtecture name e.g. android_x86_64, android_arm64
:return: condition that can be used in cc_genrule cmd to switch the behavior based on arch
'''
if arch == "android_x86_64":
return "( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' )"
elif arch == "android_x86":
return "( $$CC_ARCH == 'x86' && $$CC_OS == 'android' )"
elif arch == "android_arm":
return "( $$CC_ARCH == 'arm' && $$CC_OS == 'android' )"
elif arch == "android_arm64":
return "( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' )"
elif arch == "host":
return "$$CC_OS != 'android'"
else:
raise Exception(f'Unknown architecture type {arch}')
def merge_cmd(modules, genrule_type):
'''
:param modules: dictionary whose key is arch name and value is module
:param genrule_type: cc_genrule or java_genrule
:return: merged command or common command if all the archs have the same command.
'''
commands = list({module.cmd for module in modules.values()})
if len(commands) == 1:
# If all the archs have the same command, return the command
return commands[0]
if genrule_type != 'cc_genrule':
raise Exception(
f'{genrule_type} can not have different cmd between archs')
merged_cmd = []
for arch, module in sorted(modules.items()):
merged_cmd.append(f'if [[ {get_cmd_condition(arch)} ]];')
merged_cmd.append('then')
merged_cmd.append(module.cmd + ';')
merged_cmd.append('fi;')
return NEWLINE.join(merged_cmd)
def merge_modules(modules, genrule_type):
'''
:param modules: dictionary whose key is arch name and value is module
:param genrule_type: cc_genrule or java_genrule
:return: merged module of input modules
'''
merged_module = list(modules.values())[0]
# Following attributes must be the same between archs
for key in ('out', 'genrule_headers', 'srcs', 'tool_files'):
if any([
getattr(merged_module, key) != getattr(module, key)
for module in modules.values()
]):
raise Exception(
f'{merged_module.name} has different values for {key} between archs'
)
merged_module.cmd = merge_cmd(modules, genrule_type)
return merged_module
def create_action_module(blueprint, gn, target, genrule_type, is_test_target):
'''
Create module for action target and add to the blueprint. If target has arch specific attributes
this function merge them and create a single module.
:param blueprint:
:param target: target which is converted to the module.
:param genrule_type: cc_genrule or java_genrule
:return: created module
'''
# TODO: Handle this target correctly, this target generates java_genrule but this target has
# different value for cpu-family arg between archs
if re.match('//build/android:native_libraries_gen(__testing)?$',
target.name):
module = create_action_module_internal(gn, target, genrule_type,
is_test_target, blueprint,
target.arch['android_arm'])
blueprint.add_module(module)
return module
modules = {
arch_name:
create_action_module_internal(gn, target, genrule_type, is_test_target,
blueprint, arch)
for arch_name, arch in target.get_archs().items()
}
module = merge_modules(modules, genrule_type)
blueprint.add_module(module)
return module
def _get_cflags(cflags, defines):
cflags = {flag for flag in cflags if flag in cflag_allowlist}
# Consider proper allowlist or denylist if needed
cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines)
return cflags
def _set_linker_script(module, libs):
for lib in libs:
if lib.endswith(".lds"):
module.ldflags.add(
get_linker_script_ldflag(gn_utils.label_to_path(lib)))
def set_module_flags(module, module_type, cflags, defines, ldflags, libs):
module.cflags.update(_get_cflags(cflags, defines))
module.ldflags.update({
flag
for flag in ldflags
if flag in ldflag_allowlist or flag.startswith("-Wl,-wrap,")
})
_set_linker_script(module, libs)
# TODO: implement proper cflag parsing.
for flag in cflags:
if '-std=' in flag:
module.cpp_std = flag[len('-std='):]
if '-fexceptions' in flag:
module.cppflags.add('-fexceptions')
def set_module_include_dirs(module, cflags, include_dirs):
for flag in cflags:
if '-isystem' in flag:
module.local_include_dirs.add(flag[len('-isystem../../'):])
# Adding local_include_dirs is necessary due to source_sets / filegroups
# which do not properly propagate include directories.
# Filter any directory inside //out as a) this directory does not exist for
# aosp / soong builds and b) the include directory should already be
# configured via library dependency.
module.local_include_dirs.update([
gn_utils.label_to_path(d) for d in include_dirs
if not d.startswith('//out')
])
# Remove prohibited include directories
module.local_include_dirs = [
d for d in module.local_include_dirs
if d not in local_include_dirs_denylist
]
def create_modules_from_target(blueprint, gn, gn_target_name,
is_descendant_of_java, is_test_target):
"""Generate module(s) for a given GN target.
Given a GN target name, generate one or more corresponding modules into a
blueprint. The only case when this generates >1 module is proto libraries.
Args:
blueprint: Blueprint instance which is being generated.
gn: gn_utils.GnParser object.
gn_target_name: GN target for module generation.
"""
bp_module_name = label_to_module_name(gn_target_name)
target = gn.get_target(gn_target_name)
is_descendant_of_java = is_descendant_of_java or target.type == "java_library"
# Append __java suffix to actions reachable from java_library. This is necessary
# to differentiate them from cc actions.
# This means that a GN action of name X will be translated to two different modules of names
# X and X__java(only if X is reachable from a java target).
if target.type == "action" and is_descendant_of_java:
bp_module_name += "__java"
if bp_module_name in blueprint.modules:
return blueprint.modules[bp_module_name]
log.info('create modules for %s (%s)', target.name, target.type)
if target.type == 'executable':
if target.testonly:
module_type = 'cc_test'
else:
# Can be used for both host and device targets.
module_type = 'cc_binary'
module = Module(module_type, bp_module_name, gn_target_name)
elif target.type in ['static_library', 'source_set']:
module = Module('cc_library_static', bp_module_name, gn_target_name)
elif target.type == 'shared_library':
module = Module('cc_library_shared', bp_module_name, gn_target_name)
elif target.type == 'group':
# "group" targets are resolved recursively by gn_utils.get_target().
# There's nothing we need to do at this level for them.
return None
elif target.type == 'proto_library':
module = create_proto_modules(blueprint, gn, target)
if module is None:
return None
elif target.type == 'action':
module = create_action_module(
blueprint, gn, target,
'java_genrule' if is_descendant_of_java else 'cc_genrule',
is_test_target)
elif target.type == 'action_foreach':
module = create_action_foreach_modules(blueprint, gn, target,
is_test_target)
elif target.type == 'copy':
# TODO: careful now! copy targets are not supported yet, but this will stop
# traversing the dependency tree. For //base:base, this is not a big
# problem as libicu contains the only copy target which happens to be a
# leaf node.
return None
elif target.type == 'java_library':
if target.jar_path:
module = Module('java_import', bp_module_name, gn_target_name)
module.jars.add(target.jar_path)
else:
module = Module('java_library', bp_module_name, gn_target_name)
# Don't remove GEN_JNI from those modules as they have the real GEN_JNI that we want to include
if gn_target_name not in [
'//components/cronet/android:cronet_jni_registration_java',
'//components/cronet/android:cronet_jni_registration_java__testing',
'//components/cronet/android:cronet_tests_jni_registration_java__testing'
]:
module.jarjar_rules = REMOVE_GEN_JNI_JARJAR_RULES_FILE
module.min_sdk_version = 30
module.apex_available = [tethering_apex]
module.sdk_version = target.sdk_version
else:
raise Exception('Unknown target %s (%s)' % (target.name, target.type))
blueprint.add_module(module)
if target.type not in ['action', 'action_foreach']:
# Actions should get their srcs from their corresponding ActionSanitizer as actionSanitizer
# filters srcs differently according to the type of the action.
module.srcs.update(
gn_utils.label_to_path(src) for src in target.sources
if is_supported_source_file(src))
# Add arch-specific properties
for arch_name, arch in target.get_archs().items():
module.target[arch_name].srcs.update(
gn_utils.label_to_path(src) for src in arch.sources
if is_supported_source_file(src))
module.rtti = target.rtti
if target.type in gn_utils.LINKER_UNIT_TYPES:
set_module_flags(module, module.type, target.cflags, target.defines,
target.ldflags, target.libs)
set_module_include_dirs(module, target.cflags, target.include_dirs)
# TODO: set_module_xxx is confusing, apply similar function to module and target in better way.
for arch_name, arch in target.get_archs().items():
# TODO(aymanm): Make libs arch-specific.
set_module_flags(module.target[arch_name], module.type,
arch.cflags, arch.defines, arch.ldflags, [])
# -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions).
# Flags which does not start with '-' could not be in the cflags so enabling MTE by
# -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for
# building //base/allocator/partition_allocator:partition_alloc for arm64.
if '+mte' in arch.cflags and arch_name == 'android_arm64':
module.target[arch_name].cflags.add('-march=armv8-a+memtag')
set_module_include_dirs(module.target[arch_name], arch.cflags,
arch.include_dirs)
module.host_supported = target.host_supported()
module.device_supported = target.device_supported()
module.gn_type = target.type
if module.is_genrule():
module.apex_available.add(tethering_apex)
if module.type == "java_library":
if gn_utils.contains_aidl(target.sources):
# frameworks/base/core/java includes the source files that are used to compile framework.aidl.
# framework.aidl is added implicitly as a dependency to every AIDL GN action, this can be
# identified by third_party/android_sdk/public/platforms/android-34/framework.aidl.
module.aidl["include_dirs"] = {"frameworks/base/core/java/"}
module.aidl["local_include_dirs"] = target.local_aidl_includes
module.sdk_version = target.sdk_version
if module.is_compiled() and not module.type.startswith("java"):
# Don't try to inject library/source dependencies into genrules or
# filegroups because they are not compiled in the traditional sense.
module.defaults = [defaults_module]
for lib in target.libs:
# Generally library names should be mangled as 'libXXX', unless they
# are HAL libraries (e.g., [email protected]) or AIDL c++ / NDK
# libraries (e.g. "android.hardware.power.stats-V1-cpp")
android_lib = lib if '@' in lib or "-cpp" in lib or "-ndk" in lib \
else 'lib' + lib
if lib in shared_library_allowlist:
module.add_android_shared_lib(android_lib)
# If the module is a static library, export all the generated headers.
if module.type == 'cc_library_static':
module.export_generated_headers = module.generated_headers
if module.name in [
'cronet_aml_components_cronet_android_cronet',
'cronet_aml_components_cronet_android_cronet' +
gn_utils.TESTING_SUFFIX
]:
if target.output_name is None:
raise Exception('Failed to get output_name for libcronet name')
# .so file name needs to match with CronetLibraryLoader.java (e.g. libcronet.109.0.5386.0.so)
# So setting the output name based on the output_name from the desc.json
module.stem = 'libmainline' + target.output_name
elif module.is_test() and module.type == 'cc_library_shared':
if target.output_name:
# If we have an output name already declared, use it.
module.stem = 'lib' + target.output_name
else:
# Tests output should be a shared library in the format of 'lib[module_name]'
module.stem = 'lib' + target.get_target_name(
)[:target.get_target_name().find(gn_utils.TESTING_SUFFIX)]
# dep_name is an unmangled GN target name (e.g. //foo:bar(toolchain)).
all_deps = [(dep_name, 'common') for dep_name in target.proto_deps]
for arch_name, arch in target.arch.items():
all_deps += [(dep_name, arch_name) for dep_name in arch.deps]
# Sort deps before iteration to make result deterministic.
for (dep_name, arch_name) in sorted(all_deps):
module_target = module.target[
arch_name] if arch_name != 'common' else module
# |builtin_deps| override GN deps with Android-specific ones. See the
# config in the top of this file.
if dep_name in builtin_deps:
builtin_deps[dep_name](module, arch_name)
continue
dep_module = create_modules_from_target(blueprint, gn, dep_name,
is_descendant_of_java,
is_test_target)
if dep_module is None:
continue
# TODO: Proper dependency check for genrule.
# Currently, only propagating genrule dependencies.
# Also, currently, all the dependencies are propagated upwards.
# in gn, public_deps should be propagated but deps should not.
# Not sure this information is available in the desc.json.
# Following rule works for adding android_runtime_jni_headers to base:base.
# If this doesn't work for other target, hardcoding for specific target
# might be better.
if module.is_genrule() and dep_module.is_genrule():
if module_target.gn_type != "proto_library":
# proto_library are treated differently because each proto action
# is split into two different targets, a cpp target and a header target.
# the cpp target is used as the entry point to the proto action, hence
# it should not be propagated as a genrule header because it generates
# cpp files only.
module_target.genrule_headers.add(dep_module.name)
module_target.genrule_headers.update(dep_module.genrule_headers)
# For filegroups, and genrule, recurse but don't apply the
# deps.
if not module.is_compiled() or module.is_genrule():
continue
# Drop compiled modules that doesn't provide any benefit. This is mostly
# applicable to source_sets when converted to cc_static_library, sometimes
# the source set only has header files which are dropped so the module becomes empty.
# is_compiled is there to prevent dropping of genrules.
if dep_module.is_compiled() and not dep_module.has_input_files():
continue
if dep_module.type == 'cc_library_shared':
module_target.shared_libs.add(dep_module.name)
elif dep_module.type == 'cc_library_static':
if module.type in ['cc_library_shared', 'cc_binary']:
module_target.whole_static_libs.add(dep_module.name)
elif module.type == 'cc_library_static':
module_target.generated_headers.update(
dep_module.generated_headers)
module_target.shared_libs.update(dep_module.shared_libs)
module_target.header_libs.update(dep_module.header_libs)
elif dep_module.type == 'cc_genrule':
module_target.generated_headers.update(dep_module.genrule_headers)
module_target.srcs.update(dep_module.genrule_srcs)
module_target.shared_libs.update(dep_module.genrule_shared_libs)
module_target.header_libs.update(dep_module.genrule_header_libs)
elif dep_module.type in ['java_library', 'java_import']:
# A module depending on a module with system_current sdk version should also compile against
# the system sdk. This is because a module's SDK API surface should be >= its deps SDK API surface.
# And system_current has a larger API surface than current or module_current.
# We currently only have system_current, current or no sdk_versions in the generated bp file.
if dep_module.sdk_version == 'system_current':
module.sdk_version = 'system_current'
if module.type not in ["cc_library_static"]:
# This is needed to go around the case where `url` component depends
# on `url_java`.
# TODO(aymanm): Remove the if condition once crrev/4902547 has been imported downstream
module_target.static_libs.add(dep_module.name)
elif dep_module.type in ['genrule', 'java_genrule']:
module_target.srcs.add(":" + dep_module.name)
else:
raise Exception(
'Unsupported arch-specific dependency %s of target %s with type %s'
% (dep_module.name, target.name, dep_module.type))
return module
def turn_off_allocator_shim_for_musl(module):
allocation_shim = "base/allocator/partition_allocator/shim/allocator_shim.cc"
allocator_shim_files = {
allocation_shim,
"base/allocator/partition_allocator/shim/allocator_shim_default_dispatch_to_glibc.cc",
}
module.srcs -= allocator_shim_files
for arch in module.target.values():
arch.srcs -= allocator_shim_files
module.target['android'].srcs.add(allocation_shim)
if gn_utils.TESTING_SUFFIX in module.name:
# allocator_shim_default_dispatch_to_glibc is only added to the __testing version of base
# since base_base__testing is compiled for host. When compiling for host. Soong compiles
# using glibc or musl(experimental). We currently only support compiling for glibc.
module.target['glibc'].srcs.update(allocator_shim_files)
else:
# allocator_shim_default_dispatch_to_glibc does not exist in the prod version of base
# `base_base` since this only compiles for android and bionic is used. Bionic is the equivalent
# of glibc but for android.
module.target['glibc'].srcs.add(allocation_shim)
def create_blueprint_for_targets(gn, targets, test_targets):
"""Generate a blueprint for a list of GN targets."""
blueprint = Blueprint()
# Default settings used by all modules.
defaults = Module('cc_defaults', defaults_module, '//gn:default_deps')
defaults.cflags = [
'-DGOOGLE_PROTOBUF_NO_RTTI',
'-DBORINGSSL_SHARED_LIBRARY',
'-Wno-error=return-type',
'-Wno-non-virtual-dtor',
'-Wno-macro-redefined',
'-Wno-missing-field-initializers',
'-Wno-sign-compare',
'-Wno-sign-promo',
'-Wno-unused-parameter',
'-Wno-null-pointer-subtraction', # Needed to libevent
'-Wno-ambiguous-reversed-operator', # needed for icui18n
'-Wno-unreachable-code-loop-increment', # needed for icui18n
'-fPIC',
'-Wno-c++11-narrowing',
# b/330508686 disable coverage profiling for files or function in this list.
'-fprofile-list=external/cronet/exclude_coverage.list',
]
defaults.c_std = 'gnu11'
# Chromium builds do not add a dependency for headers found inside the
# sysroot, so they are added globally via defaults.
defaults.target['android'].header_libs = [
'jni_headers',
]
defaults.target['android'].shared_libs = ['libmediandk']
defaults.target['host'].cflags = [
# -DANDROID is added by default but target.defines contain -DANDROID if
# it's required. So adding -UANDROID to cancel default -DANDROID if it's
# not specified.
# Note: -DANDROID is not consistently applied across the chromium code
# base, so it is removed unconditionally for host targets.
'-UANDROID',
]
defaults.stl = 'none'
defaults.cpp_std = 'c++17'
defaults.min_sdk_version = 29
defaults.apex_available.add(tethering_apex)
blueprint.add_module(defaults)
for target in targets:
module = create_modules_from_target(blueprint,
gn,
target,
is_descendant_of_java=False,
is_test_target=False)
if module:
module.visibility.update(root_modules_visibility)
for test_target in test_targets:
module = create_modules_from_target(blueprint,
gn,
test_target +
gn_utils.TESTING_SUFFIX,
is_descendant_of_java=False,
is_test_target=True)
if module:
module.visibility.update(root_modules_visibility)
# Merge in additional hardcoded arguments.
for module in blueprint.modules.values():
for key, add_val in additional_args.get(module.name, []):
curr = getattr(module, key)
if add_val and isinstance(add_val, set) and isinstance(curr, set):
curr.update(add_val)
elif isinstance(add_val, str) and (not curr
or isinstance(curr, str)):
setattr(module, key, add_val)
elif isinstance(add_val, bool) and (not curr
or isinstance(curr, bool)):
setattr(module, key, add_val)
elif isinstance(add_val, dict) and isinstance(curr, dict):
curr.update(add_val)
elif isinstance(add_val[1], dict) and isinstance(
curr[add_val[0]], Module.Target):
curr[add_val[0]].__dict__.update(add_val[1])
else:
raise Exception(
'Unimplemented type %r of additional_args: %r' %
(type(add_val), key))
return blueprint
def create_package_module(blueprint):
package = Module("package", "", "PACKAGE")
package.comment = "The actual license can be found in Android.extras.bp"
package.default_applicable_licenses.add(CRONET_LICENSE_NAME)
package.default_visibility.append(package_default_visibility)
blueprint.add_module(package)
def main():
parser = argparse.ArgumentParser(
description='Generate Android.bp from a GN description.')
parser.add_argument(
'--desc',
help=
'GN description (e.g., gn desc out --format=json --all-toolchains "//*".'
+ 'You can specify multiple --desc options for different target_cpu',
required=True,
action='append')
parser.add_argument(
'--extras',
help='Extra targets to include at the end of the Blueprint file',
default=os.path.join(gn_utils.repo_root(), 'Android.bp.extras'),
)
parser.add_argument(
'--output',
help='Blueprint file to create',
default=os.path.join(gn_utils.repo_root(), 'Android.bp'),
)
parser.add_argument(
'-v',
'--verbose',
help='Print debug logs.',
action='store_true',
)
parser.add_argument(
'targets',
nargs=argparse.REMAINDER,
help='Targets to include in the blueprint (e.g., "//:perfetto_tests")')
args = parser.parse_args()
if args.verbose:
log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s',
level=log.DEBUG)
targets = args.targets or DEFAULT_TARGETS
gn = gn_utils.GnParser(builtin_deps)
for desc_file in args.desc:
with open(desc_file) as f:
desc = json.load(f)
for target in targets:
gn.parse_gn_desc(desc, target)
for test_target in DEFAULT_TESTS:
gn.parse_gn_desc(desc, test_target, is_test_target=True)
blueprint = create_blueprint_for_targets(gn, targets, DEFAULT_TESTS)
project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
tool_name = os.path.relpath(os.path.abspath(__file__), project_root)
create_package_module(blueprint)
output = [
"""// Copyright (C) 2022 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// This file is automatically generated by %s. Do not edit.
build = ["Android.extras.bp"]
""" % (tool_name)
]
blueprint.to_string(output)
if os.path.exists(args.extras):
with open(args.extras, 'r') as r:
for line in r:
output.append(line.rstrip("\n\r"))
out_files = []
# Generate the Android.bp file.
out_files.append(args.output + '.swp')
with open(out_files[-1], 'w') as f:
f.write('\n'.join(output))
# Text files should have a trailing EOL.
f.write('\n')
return 0
if __name__ == '__main__':
sys.exit(main())
Codebase Browser
chromium