def main(args):
args = build_utils.ExpandFileArgs(args)
options = _ParseArgs(args)
# Order of these must match order specified in GN so that the correct one
# appears first in the depfile.
possible_output_paths = [
options.resource_zip_out,
options.r_text_out,
options.srcjar_out,
]
output_paths = [x for x in possible_output_paths if x]
# List python deps in input_strings rather than input_paths since the contents
# of them does not change what gets written to the depsfile.
input_strings = options.extra_res_packages + [
options.custom_package,
options.shared_resources,
options.strip_drawables,
]
possible_input_paths = [
options.aapt_path,
options.android_manifest,
]
possible_input_paths += options.include_resources
input_paths = [x for x in possible_input_paths if x]
input_paths.extend(options.dependencies_res_zips)
input_paths.extend(options.extra_r_text_files)
# Resource files aren't explicitly listed in GN. Listing them in the depfile
# ensures the target will be marked stale when resource files are removed.
depfile_deps = []
resource_names = []
for resource_dir in options.resource_dirs:
for resource_file in build_utils.FindInDirectory(resource_dir, '*'):
# Don't list the empty .keep file in depfile. Since it doesn't end up
# included in the .zip, it can lead to -w 'dupbuild=err' ninja errors
# if ever moved.
if not resource_file.endswith(os.path.join('empty', '.keep')):
input_paths.append(resource_file)
depfile_deps.append(resource_file)
resource_names.append(os.path.relpath(resource_file, resource_dir))
# Resource filenames matter to the output, so add them to strings as well.
# This matters if a file is renamed but not changed (http://crbug.com/597126).
input_strings.extend(sorted(resource_names))
md5_check.CallAndWriteDepfileIfStale(
lambda: _OnStaleMd5(options),
options,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths,
depfile_deps=depfile_deps)
def main(args):
args = build_utils.ExpandFileArgs(args)
options = _ParseArgs(args)
# Order of these must match order specified in GN so that the correct one
# appears first in the depfile.
output_paths = [
options.resource_zip_out,
options.resource_zip_out + '.info',
options.r_text_out,
]
input_paths = [options.res_sources_path]
if options.r_text_in:
input_paths += [options.r_text_in]
# Resource files aren't explicitly listed in GN. Listing them in the depfile
# ensures the target will be marked stale when resource files are removed.
depfile_deps = []
resource_names = []
for resource_dir in options.resource_dirs:
for resource_file in build_utils.FindInDirectory(resource_dir, '*'):
# Don't list the empty .keep file in depfile. Since it doesn't end up
# included in the .zip, it can lead to -w 'dupbuild=err' ninja errors
# if ever moved.
if not resource_file.endswith(os.path.join('empty', '.keep')):
input_paths.append(resource_file)
depfile_deps.append(resource_file)
resource_names.append(os.path.relpath(resource_file, resource_dir))
# Resource filenames matter to the output, so add them to strings as well.
# This matters if a file is renamed but not changed (http://crbug.com/597126).
input_strings = sorted(resource_names) + [
options.shared_resources,
options.strip_drawables,
]
# Since android_resources targets like *__all_dfm_resources depend on java
# targets that they do not need (in reality it only needs the transitive
# resource targets that those java targets depend on), md5_check is used to
# prevent outputs from being re-written when real inputs have not changed.
md5_check.CallAndWriteDepfileIfStale(lambda: _OnStaleMd5(options),
options,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths,
depfile_deps=depfile_deps)
def main(args):
build_utils.InitLogging('DEX_DEBUG')
options = _ParseArgs(args)
options.class_inputs += options.class_inputs_filearg
options.dex_inputs += options.dex_inputs_filearg
input_paths = options.class_inputs + options.dex_inputs
if options.multi_dex and options.main_dex_list_path:
input_paths.append(options.main_dex_list_path)
input_paths.append(options.r8_jar_path)
output_paths = [options.output]
if options.incremental_dir:
final_dex_inputs = _IntermediateDexFilePathsFromInputJars(
options.class_inputs, options.incremental_dir)
output_paths += final_dex_inputs
track_subpaths_allowlist = options.class_inputs
else:
final_dex_inputs = list(options.class_inputs)
track_subpaths_allowlist = None
final_dex_inputs += options.dex_inputs
dex_cmd = [
build_utils.JAVA_PATH, '-jar', options.r8_jar_path, 'd8',
'--no-desugaring'
]
if options.release:
dex_cmd += ['--release']
if options.min_api:
dex_cmd += ['--min-api', options.min_api]
if options.force_enable_assertions:
dex_cmd += ['--force-enable-assertions']
md5_check.CallAndWriteDepfileIfStale(
lambda changes: _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd
),
options,
depfile_deps=options.class_inputs_filearg + options.dex_inputs_filearg,
output_paths=output_paths,
input_paths=input_paths,
input_strings=dex_cmd + [bool(options.incremental_dir)],
pass_changes=True,
track_subpaths_allowlist=track_subpaths_allowlist)
def main(args):
logging.basicConfig(
level=logging.INFO if os.environ.get('DEX_DEBUG') else logging.WARNING,
format='%(levelname).1s %(relativeCreated)6d %(message)s')
options = _ParseArgs(args)
options.class_inputs += options.class_inputs_filearg
options.dex_inputs += options.dex_inputs_filearg
input_paths = options.class_inputs + options.dex_inputs
if options.multi_dex and options.main_dex_list_path:
input_paths.append(options.main_dex_list_path)
input_paths.append(options.r8_jar_path)
output_paths = [options.output]
if options.incremental_dir:
final_dex_inputs = _IntermediateDexFilePathsFromInputJars(
options.class_inputs, options.incremental_dir)
output_paths += final_dex_inputs
track_subpaths_whitelist = options.class_inputs
else:
final_dex_inputs = list(options.class_inputs)
track_subpaths_whitelist = None
final_dex_inputs += options.dex_inputs
dex_cmd = [
build_utils.JAVA_PATH, '-jar', options.r8_jar_path, 'd8',
'--no-desugaring'
]
if options.release:
dex_cmd += ['--release']
if options.min_api:
dex_cmd += ['--min-api', options.min_api]
md5_check.CallAndWriteDepfileIfStale(
lambda changes: _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd
),
options,
depfile_deps=options.class_inputs_filearg + options.dex_inputs_filearg,
output_paths=output_paths,
input_paths=input_paths,
input_strings=dex_cmd + [bool(options.incremental_dir)],
pass_changes=True,
track_subpaths_whitelist=track_subpaths_whitelist)
def main(args):
build_utils.InitLogging('DEX_DEBUG')
options = _ParseArgs(args)
options.class_inputs += options.class_inputs_filearg
options.dex_inputs += options.dex_inputs_filearg
input_paths = options.class_inputs + options.dex_inputs
if options.multi_dex and options.main_dex_list_path:
input_paths.append(options.main_dex_list_path)
input_paths.append(options.r8_jar_path)
input_paths.append(options.custom_d8_jar_path)
depfile_deps = options.class_inputs_filearg + options.dex_inputs_filearg
output_paths = [options.output]
track_subpaths_allowlist = []
if options.incremental_dir:
final_dex_inputs = _IntermediateDexFilePathsFromInputJars(
options.class_inputs, options.incremental_dir)
output_paths += final_dex_inputs
track_subpaths_allowlist += options.class_inputs
else:
final_dex_inputs = list(options.class_inputs)
final_dex_inputs += options.dex_inputs
dex_cmd = build_utils.JavaCmd(options.warnings_as_errors) + [
'-cp',
'{}:{}'.format(options.r8_jar_path, options.custom_d8_jar_path),
'org.chromium.build.CustomD8',
]
if options.release:
dex_cmd += ['--release']
if options.min_api:
dex_cmd += ['--min-api', options.min_api]
if not options.desugar:
dex_cmd += ['--no-desugaring']
elif options.classpath:
# The classpath is used by D8 to for interface desugaring.
if options.desugar_dependencies:
dex_cmd += ['--desugar-dependencies', options.desugar_dependencies]
if track_subpaths_allowlist:
track_subpaths_allowlist += options.classpath
depfile_deps += options.classpath
input_paths += options.classpath
dex_cmd += ['--lib', build_utils.JAVA_HOME]
for path in options.bootclasspath:
dex_cmd += ['--lib', path]
# Still pass the entire classpath in case a new dependency is needed by
# desugar, so that desugar_dependencies will be updated for the next build.
for path in options.classpath:
dex_cmd += ['--classpath', path]
depfile_deps += options.bootclasspath
input_paths += options.bootclasspath
if options.desugar_jdk_libs_json:
dex_cmd += ['--desugared-lib', options.desugar_jdk_libs_json]
if options.force_enable_assertions:
dex_cmd += ['--force-enable-assertions']
# The changes feature from md5_check allows us to only re-dex the class files
# that have changed and the class files that need to be re-desugared by D8.
md5_check.CallAndWriteDepfileIfStale(
lambda changes: _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd
),
options,
input_paths=input_paths,
input_strings=dex_cmd + [bool(options.incremental_dir)],
output_paths=output_paths,
pass_changes=True,
track_subpaths_allowlist=track_subpaths_allowlist,
depfile_deps=depfile_deps)
def main(argv):
build_utils.InitLogging('JAVAC_DEBUG')
colorama.init()
argv = build_utils.ExpandFileArgs(argv)
options, java_files = _ParseOptions(argv)
javac_cmd = []
if options.gomacc_path:
javac_cmd.append(options.gomacc_path)
javac_cmd.append(build_utils.JAVAC_PATH)
javac_args = [
'-g',
# Chromium only allows UTF8 source files. Being explicit avoids
# javac pulling a default encoding from the user's environment.
'-encoding',
'UTF-8',
# Prevent compiler from compiling .java files not listed as inputs.
# See: http://blog.ltgt.net/most-build-tools-misuse-javac/
'-sourcepath',
':',
]
if options.enable_errorprone:
# All errorprone args are passed space-separated in a single arg.
errorprone_flags = ['-Xplugin:ErrorProne']
for warning in ERRORPRONE_WARNINGS_TO_TURN_OFF:
errorprone_flags.append('-Xep:{}:OFF'.format(warning))
for warning in ERRORPRONE_WARNINGS_TO_ERROR:
errorprone_flags.append('-Xep:{}:ERROR'.format(warning))
if not options.warnings_as_errors:
errorprone_flags.append('-XepAllErrorsAsWarnings')
javac_args += ['-XDcompilePolicy=simple', ' '.join(errorprone_flags)]
# This flag quits errorprone after checks and before code generation, since
# we do not need errorprone outputs, this speeds up errorprone by 4 seconds
# for chrome_java.
javac_args += ['-XDshould-stop.ifNoError=FLOW']
if options.java_version:
javac_args.extend([
'-source',
options.java_version,
'-target',
options.java_version,
])
if options.java_version == '1.8':
# Android's boot jar doesn't contain all java 8 classes.
options.bootclasspath.append(build_utils.RT_JAR_PATH)
if options.warnings_as_errors:
javac_args.extend(['-Werror'])
else:
# XDignore.symbol.file makes javac compile against rt.jar instead of
# ct.sym. This means that using a java internal package/class will not
# trigger a compile warning or error.
javac_args.extend(['-XDignore.symbol.file'])
if options.processors:
javac_args.extend(['-processor', ','.join(options.processors)])
else:
# This effectively disables all annotation processors, even including
# annotation processors in service provider configuration files named
# META-INF/. See the following link for reference:
# https://docs.oracle.com/en/java/javase/11/tools/javac.html
javac_args.extend(['-proc:none'])
if options.bootclasspath:
javac_args.extend(['-bootclasspath', ':'.join(options.bootclasspath)])
if options.processorpath:
javac_args.extend(['-processorpath', ':'.join(options.processorpath)])
if options.processor_args:
for arg in options.processor_args:
javac_args.extend(['-A%s' % arg])
javac_args.extend(options.javac_arg)
classpath_inputs = (
options.bootclasspath + options.classpath + options.processorpath)
depfile_deps = classpath_inputs
# Files that are already inputs in GN should go in input_paths.
input_paths = depfile_deps + options.java_srcjars + java_files
if options.header_jar:
input_paths.append(options.header_jar)
input_paths += [x[0] for x in options.additional_jar_files]
output_paths = [
options.jar_path,
options.jar_path + '.info',
]
input_strings = javac_cmd + javac_args + options.classpath + java_files
if options.jar_info_exclude_globs:
input_strings.append(options.jar_info_exclude_globs)
md5_check.CallAndWriteDepfileIfStale(
lambda: _OnStaleMd5(options, javac_cmd, javac_args, java_files),
options,
depfile_deps=depfile_deps,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths)
def main(args):
build_utils.InitLogging('RESOURCE_DEBUG')
args = build_utils.ExpandFileArgs(args)
options = _ParseArgs(args)
if options.expected_file:
actual_data = _CreateNormalizedManifest(options)
diff_utils.CheckExpectations(actual_data, options)
if options.only_verify_expectations:
return
depfile_deps = (options.dependencies_res_zips +
options.dependencies_res_zip_overlays +
options.extra_main_r_text_files +
options.include_resources)
possible_input_paths = depfile_deps + options.resources_config_paths + [
options.aapt2_path,
options.android_manifest,
options.expected_file,
options.expected_file_base,
options.shared_resources_allowlist,
options.use_resource_ids_path,
options.webp_binary,
]
input_paths = [p for p in possible_input_paths if p]
input_strings = [
options.app_as_shared_lib,
options.arsc_package_name,
options.debuggable,
options.extra_res_packages,
options.failure_file,
options.include_resources,
options.locale_allowlist,
options.manifest_package,
options.max_sdk_version,
options.min_sdk_version,
options.no_xml_namespaces,
options.package_id,
options.package_name,
options.png_to_webp,
options.rename_manifest_package,
options.resource_exclusion_exceptions,
options.resource_exclusion_regex,
options.r_java_root_package_name,
options.shared_resources,
options.shared_resources_allowlist_locales,
options.short_resource_paths,
options.strip_resource_names,
options.support_zh_hk,
options.target_sdk_version,
options.values_filter_rules,
options.version_code,
options.version_name,
options.webp_cache_dir,
]
output_paths = [options.srcjar_out]
possible_output_paths = [
options.actual_file,
options.arsc_path,
options.emit_ids_out,
options.info_path,
options.optimized_arsc_path,
options.optimized_proto_path,
options.proguard_file,
options.proguard_file_main_dex,
options.proto_path,
options.resources_path_map_out_path,
options.r_text_out,
]
output_paths += [p for p in possible_output_paths if p]
# Since we overspecify deps, this target depends on java deps that are not
# going to change its output. This target is also slow (6-12 seconds) and
# blocking the critical path. We want changes to java_library targets to not
# trigger re-compilation of resources, thus we need to use md5_check.
md5_check.CallAndWriteDepfileIfStale(lambda: _OnStaleMd5(options),
options,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths,
depfile_deps=depfile_deps)
def main(argv):
build_utils.InitLogging('JAVAC_DEBUG')
argv = build_utils.ExpandFileArgs(argv)
options, java_files = _ParseOptions(argv)
# Only use the build server for errorprone runs.
if (options.enable_errorprone and not options.skip_build_server
and server_utils.MaybeRunCommand(name=options.target_name,
argv=sys.argv,
stamp_file=options.jar_path)):
return
javac_cmd = []
if options.gomacc_path:
javac_cmd.append(options.gomacc_path)
javac_cmd.append(build_utils.JAVAC_PATH)
javac_args = [
'-g',
# Chromium only allows UTF8 source files. Being explicit avoids
# javac pulling a default encoding from the user's environment.
'-encoding',
'UTF-8',
# Prevent compiler from compiling .java files not listed as inputs.
# See: http://blog.ltgt.net/most-build-tools-misuse-javac/
'-sourcepath',
':',
]
if options.enable_errorprone:
# All errorprone args are passed space-separated in a single arg.
errorprone_flags = ['-Xplugin:ErrorProne']
# Make everything a warning so that when treat_warnings_as_errors is false,
# they do not fail the build.
errorprone_flags += ['-XepAllErrorsAsWarnings']
# Don't check generated files.
errorprone_flags += ['-XepDisableWarningsInGeneratedCode']
errorprone_flags.extend('-Xep:{}:OFF'.format(x)
for x in ERRORPRONE_WARNINGS_TO_DISABLE)
errorprone_flags.extend('-Xep:{}:WARN'.format(x)
for x in ERRORPRONE_WARNINGS_TO_ENABLE)
if ERRORPRONE_CHECKS_TO_APPLY:
errorprone_flags += [
'-XepPatchLocation:IN_PLACE',
'-XepPatchChecks:,' + ','.join(ERRORPRONE_CHECKS_TO_APPLY)
]
javac_args += ['-XDcompilePolicy=simple', ' '.join(errorprone_flags)]
# This flag quits errorprone after checks and before code generation, since
# we do not need errorprone outputs, this speeds up errorprone by 4 seconds
# for chrome_java.
if not ERRORPRONE_CHECKS_TO_APPLY:
javac_args += ['-XDshould-stop.ifNoError=FLOW']
if options.java_version:
javac_args.extend([
'-source',
options.java_version,
'-target',
options.java_version,
])
if options.java_version == '1.8':
# Android's boot jar doesn't contain all java 8 classes.
options.bootclasspath.append(build_utils.RT_JAR_PATH)
# This effectively disables all annotation processors, even including
# annotation processors in service provider configuration files named
# META-INF/. See the following link for reference:
# https://docs.oracle.com/en/java/javase/11/tools/javac.html
javac_args.extend(['-proc:none'])
if options.bootclasspath:
javac_args.extend(['-bootclasspath', ':'.join(options.bootclasspath)])
if options.processorpath:
javac_args.extend(['-processorpath', ':'.join(options.processorpath)])
if options.processor_args:
for arg in options.processor_args:
javac_args.extend(['-A%s' % arg])
javac_args.extend(options.javac_arg)
classpath_inputs = (options.bootclasspath + options.classpath +
options.processorpath)
depfile_deps = classpath_inputs
# Files that are already inputs in GN should go in input_paths.
input_paths = depfile_deps + options.java_srcjars + java_files
if options.header_jar:
input_paths.append(options.header_jar)
input_paths += [x[0] for x in options.additional_jar_files]
output_paths = [options.jar_path]
if not options.enable_errorprone:
output_paths += [options.jar_path + '.info']
input_strings = javac_cmd + javac_args + options.classpath + java_files + [
options.warnings_as_errors, options.jar_info_exclude_globs
]
# Use md5_check for |pass_changes| feature.
md5_check.CallAndWriteDepfileIfStale(lambda changes: _OnStaleMd5(
changes, options, javac_cmd, javac_args, java_files),
options,
depfile_deps=depfile_deps,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths,
pass_changes=True)
def main(argv):
build_utils.InitLogging('JAVAC_DEBUG')
colorama.init()
argv = build_utils.ExpandFileArgs(argv)
options, java_files = _ParseOptions(argv)
javac_path = build_utils.JAVAC_PATH
javac_cmd = [
javac_path,
'-g',
# Chromium only allows UTF8 source files. Being explicit avoids
# javac pulling a default encoding from the user's environment.
'-encoding',
'UTF-8',
# Prevent compiler from compiling .java files not listed as inputs.
# See: http://blog.ltgt.net/most-build-tools-misuse-javac/
'-sourcepath',
':',
]
if options.enable_errorprone:
# All errorprone args are passed space-separated in a single arg.
errorprone_flags = ['-Xplugin:ErrorProne']
for warning in ERRORPRONE_WARNINGS_TO_TURN_OFF:
errorprone_flags.append('-Xep:{}:OFF'.format(warning))
for warning in ERRORPRONE_WARNINGS_TO_ERROR:
errorprone_flags.append('-Xep:{}:ERROR'.format(warning))
if not options.warnings_as_errors:
errorprone_flags.append('-XepAllErrorsAsWarnings')
javac_cmd += ['-XDcompilePolicy=simple', ' '.join(errorprone_flags)]
if options.java_version:
javac_cmd.extend([
'-source',
options.java_version,
'-target',
options.java_version,
])
if options.java_version == '1.8':
# Android's boot jar doesn't contain all java 8 classes.
options.bootclasspath.append(build_utils.RT_JAR_PATH)
if options.warnings_as_errors:
javac_cmd.extend(['-Werror'])
else:
# XDignore.symbol.file makes javac compile against rt.jar instead of
# ct.sym. This means that using a java internal package/class will not
# trigger a compile warning or error.
javac_cmd.extend(['-XDignore.symbol.file'])
if options.processors:
javac_cmd.extend(['-processor', ','.join(options.processors)])
if options.bootclasspath:
javac_cmd.extend(['-bootclasspath', ':'.join(options.bootclasspath)])
if options.processorpath:
javac_cmd.extend(['-processorpath', ':'.join(options.processorpath)])
if options.processor_args:
for arg in options.processor_args:
javac_cmd.extend(['-A%s' % arg])
javac_cmd.extend(options.javac_arg)
classpath_inputs = (options.bootclasspath + options.classpath +
options.processorpath)
# GN already knows of java_files, so listing them just make things worse when
# they change.
depfile_deps = classpath_inputs + options.java_srcjars
input_paths = depfile_deps + java_files
input_paths += [x[0] for x in options.additional_jar_files]
output_paths = [
options.jar_path,
options.jar_path + '.info',
]
input_strings = javac_cmd + options.classpath + java_files
if options.jar_info_exclude_globs:
input_strings.append(options.jar_info_exclude_globs)
md5_check.CallAndWriteDepfileIfStale(
lambda: _OnStaleMd5(options, javac_cmd, java_files, options.classpath),
options,
depfile_deps=depfile_deps,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths)
def main(args):
build_utils.InitLogging('DEX_DEBUG')
options = _ParseArgs(args)
options.class_inputs += options.class_inputs_filearg
options.dex_inputs += options.dex_inputs_filearg
input_paths = options.class_inputs + options.dex_inputs
if options.multi_dex and options.main_dex_list_path:
input_paths.append(options.main_dex_list_path)
input_paths.append(options.r8_jar_path)
depfile_deps = options.class_inputs_filearg + options.dex_inputs_filearg
output_paths = [options.output]
if options.incremental_dir:
final_dex_inputs = _IntermediateDexFilePathsFromInputJars(
options.class_inputs, options.incremental_dir)
output_paths += final_dex_inputs
track_subpaths_allowlist = options.class_inputs
else:
final_dex_inputs = list(options.class_inputs)
track_subpaths_allowlist = None
final_dex_inputs += options.dex_inputs
dex_cmd = build_utils.JavaCmd(options.warnings_as_errors) + [
'-cp',
options.r8_jar_path,
'com.android.tools.r8.D8',
]
if options.release:
dex_cmd += ['--release']
if options.min_api:
dex_cmd += ['--min-api', options.min_api]
if not options.desugar:
dex_cmd += ['--no-desugaring']
elif options.classpath:
# Don't pass classpath when Desugar.jar is doing interface desugaring.
dex_cmd += ['--lib', build_utils.JAVA_HOME]
for path in options.bootclasspath:
dex_cmd += ['--lib', path]
for path in options.classpath:
dex_cmd += ['--classpath', path]
depfile_deps += options.classpath
depfile_deps += options.bootclasspath
input_paths += options.classpath
input_paths += options.bootclasspath
if options.desugar_jdk_libs_json:
dex_cmd += ['--desugared-lib', options.desugar_jdk_libs_json]
if options.force_enable_assertions:
dex_cmd += ['--force-enable-assertions']
md5_check.CallAndWriteDepfileIfStale(
lambda changes: _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd
),
options,
input_paths=input_paths,
input_strings=dex_cmd + [bool(options.incremental_dir)],
output_paths=output_paths,
pass_changes=True,
track_subpaths_allowlist=track_subpaths_allowlist,
depfile_deps=depfile_deps)
def main():
parser = argparse.ArgumentParser()
build_utils.AddDepfileOption(parser)
parser.add_argument('--lint-path', required=True,
help='Path to lint executable.')
parser.add_argument('--product-dir', required=True,
help='Path to product dir.')
parser.add_argument('--result-path', required=True,
help='Path to XML lint result file.')
parser.add_argument('--cache-dir', required=True,
help='Path to the directory in which the android cache '
'directory tree should be stored.')
parser.add_argument('--platform-xml-path', required=True,
help='Path to api-platforms.xml')
parser.add_argument('--android-sdk-version',
help='Version (API level) of the Android SDK used for '
'building.')
parser.add_argument('--can-fail-build', action='store_true',
help='If set, script will exit with nonzero exit status'
' if lint errors are present')
parser.add_argument('--include-unexpected-failures', action='store_true',
help='If set, script will exit with nonzero exit status'
' if lint itself crashes with unexpected failures.')
parser.add_argument('--config-path',
help='Path to lint suppressions file.')
parser.add_argument('--disable',
help='List of checks to disable.')
parser.add_argument('--jar-path',
help='Jar file containing class files.')
parser.add_argument('--java-sources-file',
help='File containing a list of java files.')
parser.add_argument('--manifest-path',
help='Path to AndroidManifest.xml')
parser.add_argument('--classpath', default=[], action='append',
help='GYP-list of classpath .jar files')
parser.add_argument('--processed-config-path',
help='Path to processed lint suppressions file.')
parser.add_argument('--resource-dir',
help='Path to resource dir.')
parser.add_argument('--resource-sources', default=[], action='append',
help='GYP-list of resource sources (directories with '
'resources or archives created by resource-generating '
'tasks.')
parser.add_argument('--silent', action='store_true',
help='If set, script will not log anything.')
parser.add_argument('--src-dirs',
help='Directories containing java files.')
parser.add_argument('--srcjars',
help='GN list of included srcjars.')
parser.add_argument(
'--min-sdk-version',
required=True,
help='Minimal SDK version to lint against.')
parser.add_argument(
'--manifest-package', help='Package name of the AndroidManifest.xml.')
args = parser.parse_args(build_utils.ExpandFileArgs(sys.argv[1:]))
sources = []
if args.src_dirs:
src_dirs = build_utils.ParseGnList(args.src_dirs)
sources = _FindInDirectories(src_dirs, '*.java')
elif args.java_sources_file:
sources.extend(build_utils.ReadSourcesList(args.java_sources_file))
if args.config_path and not args.processed_config_path:
parser.error('--config-path specified without --processed-config-path')
elif args.processed_config_path and not args.config_path:
parser.error('--processed-config-path specified without --config-path')
input_paths = [
args.lint_path,
args.platform_xml_path,
]
if args.config_path:
input_paths.append(args.config_path)
if args.jar_path:
input_paths.append(args.jar_path)
if args.manifest_path:
input_paths.append(args.manifest_path)
if sources:
input_paths.extend(sources)
classpath = []
for gyp_list in args.classpath:
classpath.extend(build_utils.ParseGnList(gyp_list))
input_paths.extend(classpath)
resource_sources = []
if args.resource_dir:
# Backward compatibility with GYP
resource_sources += [ args.resource_dir ]
for gyp_list in args.resource_sources:
resource_sources += build_utils.ParseGnList(gyp_list)
for resource_source in resource_sources:
if os.path.isdir(resource_source):
input_paths.extend(build_utils.FindInDirectory(resource_source, '*'))
else:
input_paths.append(resource_source)
input_strings = [
args.can_fail_build,
args.include_unexpected_failures,
args.silent,
]
if args.android_sdk_version:
input_strings.append(args.android_sdk_version)
if args.processed_config_path:
input_strings.append(args.processed_config_path)
disable = []
if args.disable:
disable = build_utils.ParseGnList(args.disable)
input_strings.extend(disable)
output_paths = [args.result_path, args.processed_config_path]
md5_check.CallAndWriteDepfileIfStale(
lambda: _OnStaleMd5(args.lint_path,
args.config_path,
args.processed_config_path,
args.manifest_path, args.result_path,
args.product_dir, sources,
args.jar_path,
args.cache_dir,
args.android_sdk_version,
args.srcjars,
args.min_sdk_version,
args.manifest_package,
resource_sources,
disable=disable,
classpath=classpath,
can_fail_build=args.can_fail_build,
include_unexpected=args.include_unexpected_failures,
silent=args.silent),
args,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths,
depfile_deps=classpath)
def main(args):
build_utils.InitLogging('DEX_DEBUG')
options = _ParseArgs(args)
options.class_inputs += options.class_inputs_filearg
options.dex_inputs += options.dex_inputs_filearg
input_paths = options.class_inputs + options.dex_inputs
if options.multi_dex and options.main_dex_list_path:
input_paths.append(options.main_dex_list_path)
input_paths.append(options.r8_jar_path)
input_paths.append(options.custom_d8_jar_path)
depfile_deps = options.class_inputs_filearg + options.dex_inputs_filearg
output_paths = [options.output]
if options.incremental_dir:
final_dex_inputs = _IntermediateDexFilePathsFromInputJars(
options.class_inputs, options.incremental_dir)
output_paths += final_dex_inputs
track_subpaths_allowlist = options.class_inputs
else:
final_dex_inputs = list(options.class_inputs)
track_subpaths_allowlist = None
final_dex_inputs += options.dex_inputs
dex_cmd = build_utils.JavaCmd(options.warnings_as_errors) + [
'-cp',
'{}:{}'.format(options.r8_jar_path, options.custom_d8_jar_path),
'org.chromium.build.CustomD8',
]
if options.release:
dex_cmd += ['--release']
if options.min_api:
dex_cmd += ['--min-api', options.min_api]
if not options.desugar:
dex_cmd += ['--no-desugaring']
elif options.classpath:
# The classpath is used by D8 to for interface desugaring.
classpath_paths = options.classpath
if options.desugar_dependencies:
dex_cmd += ['--desugar-dependencies', options.desugar_dependencies]
if os.path.exists(options.desugar_dependencies):
with open(options.desugar_dependencies, 'r') as f:
lines = [line.strip() for line in f.readlines()]
# Use a set to deduplicate entries.
desugar_dependencies = set(dep for dep in lines if dep)
# Desugar dependencies are a subset of classpath.
classpath_paths = list(desugar_dependencies)
depfile_deps += classpath_paths
input_paths += classpath_paths
dex_cmd += ['--lib', build_utils.JAVA_HOME]
for path in options.bootclasspath:
dex_cmd += ['--lib', path]
# Still pass the entire classpath in case a new dependency is needed by
# desugar, so that desugar_dependencies will be updated for the next build.
for path in options.classpath:
dex_cmd += ['--classpath', path]
depfile_deps += options.bootclasspath
input_paths += options.bootclasspath
if options.desugar_jdk_libs_json:
dex_cmd += ['--desugared-lib', options.desugar_jdk_libs_json]
if options.force_enable_assertions:
dex_cmd += ['--force-enable-assertions']
md5_check.CallAndWriteDepfileIfStale(
lambda changes: _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd
),
options,
input_paths=input_paths,
input_strings=dex_cmd + [bool(options.incremental_dir)],
output_paths=output_paths,
pass_changes=True,
track_subpaths_allowlist=track_subpaths_allowlist,
depfile_deps=depfile_deps)
def main(argv):
build_utils.InitLogging('TURBINE_DEBUG')
argv = build_utils.ExpandFileArgs(argv[1:])
parser = argparse.ArgumentParser()
build_utils.AddDepfileOption(parser)
parser.add_argument('--turbine-jar-path',
required=True,
help='Path to the turbine jar file.')
parser.add_argument('--java-srcjars',
action='append',
default=[],
help='List of srcjars to include in compilation.')
parser.add_argument(
'--bootclasspath',
action='append',
default=[],
help='Boot classpath for javac. If this is specified multiple times, '
'they will all be appended to construct the classpath.')
parser.add_argument(
'--java-version',
help=
'Java language version to use in -source and -target args to javac.')
parser.add_argument('--classpath',
action='append',
help='Classpath to use.')
parser.add_argument('--processors',
action='append',
help='GN list of annotation processor main classes.')
parser.add_argument(
'--processorpath',
action='append',
help='GN list of jars that comprise the classpath used for Annotation '
'Processors.')
parser.add_argument(
'--processor-args',
action='append',
help='key=value arguments for the annotation processors.')
parser.add_argument('--jar-path', help='Jar output path.', required=True)
parser.add_argument('--generated-jar-path',
required=True,
help='Output path for generated source files.')
options, unknown_args = parser.parse_known_args(argv)
options.bootclasspath = build_utils.ParseGnList(options.bootclasspath)
options.classpath = build_utils.ParseGnList(options.classpath)
options.processorpath = build_utils.ParseGnList(options.processorpath)
options.processors = build_utils.ParseGnList(options.processors)
options.java_srcjars = build_utils.ParseGnList(options.java_srcjars)
files = []
for arg in unknown_args:
# Interpret a path prefixed with @ as a file containing a list of sources.
if arg.startswith('@'):
files.extend(build_utils.ReadSourcesList(arg[1:]))
cmd = [
build_utils.JAVA_PATH, '-classpath', options.turbine_jar_path,
'com.google.turbine.main.Main'
]
javac_cmd = []
# Turbine reads lists from command line args by consuming args until one
# starts with double dash (--). Thus command line args should be grouped
# together and passed in together.
if options.processors:
cmd += ['--processors']
cmd += options.processors
if options.java_version:
javac_cmd.extend([
'-source',
options.java_version,
'-target',
options.java_version,
])
if options.java_version == '1.8':
# Android's boot jar doesn't contain all java 8 classes.
options.bootclasspath.append(build_utils.RT_JAR_PATH)
if options.bootclasspath:
cmd += ['--bootclasspath']
for bootclasspath in options.bootclasspath:
cmd += bootclasspath.split(':')
if options.processorpath:
cmd += ['--processorpath']
cmd += options.processorpath
if options.processor_args:
for arg in options.processor_args:
javac_cmd.extend(['-A%s' % arg])
classpath_inputs = (options.bootclasspath + options.classpath +
options.processorpath)
# GN already knows of the java files, so avoid listing individual java files
# in the depfile.
depfile_deps = classpath_inputs + options.java_srcjars
input_paths = depfile_deps + files
output_paths = [
options.jar_path,
options.generated_jar_path,
]
input_strings = cmd + options.classpath + files
md5_check.CallAndWriteDepfileIfStale(
lambda: _OnStaleMd5(options, cmd, javac_cmd, files, options.classpath),
options,
depfile_deps=depfile_deps,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths)
