build/config/android/internal_rules.gni

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import("//build/config/android/config.gni")
   6
   7 assert(is_android)
   8
   9 rebased_android_sdk = rebase_path(android_sdk, root_build_dir)
  10 rebased_android_sdk_root = rebase_path(android_sdk_root, root_build_dir)
  11 rebased_android_sdk_build_tools =
  12     rebase_path(android_sdk_build_tools, root_build_dir)
  13
  14 android_sdk_jar = "$android_sdk/android.jar"
  15 rebased_android_sdk_jar = rebase_path(android_sdk_jar, root_build_dir)
  16
  17 template("android_lint") {
  18   set_sources_assignment_filter([])
  19   if (defined(invoker.testonly)) {
  20     testonly = invoker.testonly
  21   }
  22
  23   jar_path = invoker.jar_path
  24   android_manifest = invoker.android_manifest
  25   java_files = invoker.java_files
  26   base_path = "$target_gen_dir/$target_name"
  27
  28   action(target_name) {
  29     script = "//build/android/gyp/lint.py"
  30     result_path = base_path + "/result.xml"
  31     config_path = base_path + "/config.xml"
  32     suppressions_file = "//build/android/lint/suppressions.xml"
  33     inputs = [
  34                suppressions_file,
  35                android_manifest,
  36                jar_path,
  37              ] + java_files
  38
  39     outputs = [
  40       config_path,
  41       result_path,
  42     ]
  43
  44     rebased_java_files = rebase_path(java_files, root_build_dir)
  45
  46     args = [
  47       "--lint-path=$rebased_android_sdk_root/tools/lint",
  48       "--config-path",
  49       rebase_path(suppressions_file, root_build_dir),
  50       "--manifest-path",
  51       rebase_path(android_manifest, root_build_dir),
  52       "--product-dir=.",
  53       "--jar-path",
  54       rebase_path(jar_path, root_build_dir),
  55       "--processed-config-path",
  56       rebase_path(config_path, root_build_dir),
  57       "--result-path",
  58       rebase_path(result_path, root_build_dir),
  59       "--java-files=$rebased_java_files",
  60       "--enable",
  61     ]
  62   }
  63 }
  64
  65 template("dex") {
  66   set_sources_assignment_filter([])
  67   if (defined(invoker.testonly)) {
  68     testonly = invoker.testonly
  69   }
  70
  71   assert(defined(invoker.output))
  72   action(target_name) {
  73     script = "//build/android/gyp/dex.py"
  74     depfile = "$target_gen_dir/$target_name.d"
  75     if (defined(invoker.sources)) {
  76       sources = invoker.sources
  77     }
  78     outputs = [
  79       depfile,
  80       invoker.output,
  81     ]
  82     if (defined(invoker.inputs)) {
  83       inputs = invoker.inputs
  84     }
  85
  86     if (defined(invoker.deps)) {
  87       deps = invoker.deps
  88     }
  89
  90     rebased_output = rebase_path(invoker.output, root_build_dir)
  91
  92     args = [
  93       "--depfile",
  94       rebase_path(depfile, root_build_dir),
  95       "--android-sdk-tools",
  96       rebased_android_sdk_build_tools,
  97       "--dex-path",
  98       rebased_output,
  99     ]
 100
 101     if (defined(invoker.no_locals) && invoker.no_locals) {
 102       args += [ "--no-locals=1" ]
 103     }
 104
 105     if (defined(invoker.args)) {
 106       args += invoker.args
 107     }
 108
 109     if (defined(invoker.sources)) {
 110       args += rebase_path(invoker.sources, root_build_dir)
 111     }
 112   }
 113 }
 114
 115 # Creates a zip archive of the inputs.
 116 # If base_dir is provided, the archive paths will be relative to it.
 117 template("zip") {
 118   set_sources_assignment_filter([])
 119   if (defined(invoker.testonly)) {
 120     testonly = invoker.testonly
 121   }
 122
 123   assert(defined(invoker.inputs))
 124   assert(defined(invoker.output))
 125
 126   rebase_inputs = rebase_path(invoker.inputs, root_build_dir)
 127   rebase_output = rebase_path(invoker.output, root_build_dir)
 128   action(target_name) {
 129     script = "//build/android/gn/zip.py"
 130     depfile = "$target_gen_dir/$target_name.d"
 131     inputs = invoker.inputs
 132     outputs = [
 133       depfile,
 134       invoker.output,
 135     ]
 136     args = [
 137       "--depfile",
 138       rebase_path(depfile, root_build_dir),
 139       "--inputs=$rebase_inputs",
 140       "--output=$rebase_output",
 141     ]
 142     if (defined(invoker.base_dir)) {
 143       args += [
 144         "--base-dir",
 145         rebase_path(invoker.base_dir, root_build_dir),
 146       ]
 147     }
 148   }
 149 }
 150
 151 # Write the target's .build_config file. This is a json file that contains a
 152 # dictionary of information about how to build this target (things that
 153 # require knowledge about this target's dependencies and cannot be calculated
 154 # at gn-time). There is a special syntax to add a value in that dictionary to
 155 # an action/action_foreachs args:
 156 #   --python-arg=@FileArg($rebased_build_config_path:key0:key1)
 157 # At runtime, such an arg will be replaced by the value in the build_config.
 158 # See build/android/gyp/write_build_config.py and
 159 # build/android/gyp/util/build_utils.py:ExpandFileArgs
 160 template("write_build_config") {
 161   set_sources_assignment_filter([])
 162   if (defined(invoker.testonly)) {
 163     testonly = invoker.testonly
 164   }
 165
 166   assert(defined(invoker.type))
 167   assert(defined(invoker.build_config))
 168
 169   type = invoker.type
 170   build_config = invoker.build_config
 171
 172   assert(type == "android_apk" || type == "java_library" ||
 173          type == "android_resources" || type == "deps_dex")
 174
 175   action(target_name) {
 176     script = "//build/android/gyp/write_build_config.py"
 177     depfile = "$target_gen_dir/$target_name.d"
 178     inputs = []
 179
 180     deps = []
 181     if (defined(invoker.deps)) {
 182       deps += invoker.deps
 183     }
 184
 185     possible_deps_configs = []
 186     foreach(d, deps) {
 187       dep_gen_dir = get_label_info(d, "target_gen_dir")
 188       dep_name = get_label_info(d, "name")
 189       possible_deps_configs += [ "$dep_gen_dir/$dep_name.build_config" ]
 190     }
 191     rebase_possible_deps_configs = rebase_path(possible_deps_configs)
 192
 193     outputs = [
 194       depfile,
 195       build_config,
 196     ]
 197
 198     args = [
 199       "--type",
 200       type,
 201       "--depfile",
 202       rebase_path(depfile, root_build_dir),
 203       "--possible-deps-configs=$rebase_possible_deps_configs",
 204       "--build-config",
 205       rebase_path(build_config, root_build_dir),
 206     ]
 207
 208     is_java_library = type == "java_library"
 209     is_apk = type == "android_apk"
 210     is_android_resources = type == "android_resources"
 211     is_deps_dex = type == "deps_dex"
 212
 213     supports_android = is_apk || is_android_resources || is_deps_dex ||
 214                        (is_java_library && defined(invoker.supports_android) &&
 215                         invoker.supports_android)
 216     requires_android = is_apk || is_android_resources || is_deps_dex ||
 217                        (is_java_library && defined(invoker.requires_android) &&
 218                         invoker.requires_android)
 219
 220     assert(!requires_android || supports_android,
 221            "requires_android requires" + " supports_android")
 222
 223     # Mark these variables as used.
 224     assert(is_java_library || true)
 225     assert(is_apk || true)
 226     assert(is_android_resources || true)
 227     assert(is_deps_dex || true)
 228
 229     if (is_java_library || is_apk) {
 230       args += [
 231         "--jar-path",
 232         rebase_path(invoker.jar_path, root_build_dir),
 233       ]
 234     }
 235
 236     if (is_apk || is_deps_dex || (is_java_library && supports_android)) {
 237       args += [
 238         "--dex-path",
 239         rebase_path(invoker.dex_path, root_build_dir),
 240       ]
 241     }
 242     if (supports_android) {
 243       args += [ "--supports-android" ]
 244     }
 245     if (requires_android) {
 246       args += [ "--requires-android" ]
 247     }
 248     if (defined(invoker.bypass_platform_checks) &&
 249         invoker.bypass_platform_checks) {
 250       args += [ "--bypass-platform-checks" ]
 251     }
 252
 253     if (is_android_resources || is_apk) {
 254       assert(defined(invoker.resources_zip))
 255       args += [
 256         "--resources-zip",
 257         rebase_path(invoker.resources_zip, root_build_dir),
 258       ]
 259       if (defined(invoker.android_manifest)) {
 260         inputs += [ invoker.android_manifest ]
 261         args += [
 262           "--android-manifest",
 263           rebase_path(invoker.android_manifest, root_build_dir),
 264         ]
 265       }
 266       if (defined(invoker.custom_package)) {
 267         args += [
 268           "--package-name",
 269           invoker.custom_package,
 270         ]
 271       }
 272     }
 273
 274     if (is_apk) {
 275       if (defined(invoker.native_libs)) {
 276         inputs += invoker.native_libs
 277         rebased_native_libs = rebase_path(invoker.native_libs, root_build_dir)
 278         rebased_android_readelf = rebase_path(android_readelf, root_build_dir)
 279         args += [
 280           "--native-libs=$rebased_native_libs",
 281           "--readelf-path=$rebased_android_readelf",
 282         ]
 283       }
 284     }
 285
 286     if (defined(invoker.srcjar)) {
 287       args += [
 288         "--srcjar",
 289         rebase_path(invoker.srcjar, root_build_dir),
 290       ]
 291     }
 292   }
 293 }
 294
 295 template("process_java_prebuilt") {
 296   set_sources_assignment_filter([])
 297   if (defined(invoker.testonly)) {
 298     testonly = invoker.testonly
 299   }
 300
 301   _input_jar_path = invoker.input_jar_path
 302   _output_jar_path = invoker.output_jar_path
 303   _jar_toc_path = _output_jar_path + ".TOC"
 304
 305   assert(invoker.build_config != "")
 306
 307   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 308     _proguard_jar_path = "$android_sdk_root/tools/proguard/lib/proguard.jar"
 309     _proguard_config_path = invoker.proguard_config
 310     _build_config = invoker.build_config
 311     _rebased_build_config = rebase_path(_build_config, root_build_dir)
 312     action("${target_name}__proguard_process") {
 313       script = "//build/android/gyp/proguard.py"
 314       inputs = [
 315         android_sdk_jar,
 316         _proguard_jar_path,
 317         _build_config,
 318         _input_jar_path,
 319         _proguard_config_path,
 320       ]
 321       depfile = "${target_gen_dir}/${target_name}.d"
 322       outputs = [
 323         depfile,
 324         _output_jar_path,
 325       ]
 326       args = [
 327         "--depfile",
 328         rebase_path(depfile, root_build_dir),
 329         "--proguard-path",
 330         rebase_path(_proguard_jar_path, root_build_dir),
 331         "--input-path",
 332         rebase_path(_input_jar_path, root_build_dir),
 333         "--output-path",
 334         rebase_path(_output_jar_path, root_build_dir),
 335         "--proguard-config",
 336         rebase_path(_proguard_config_path, root_build_dir),
 337         "--classpath",
 338         rebased_android_sdk_jar,
 339         "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 340       ]
 341     }
 342   } else {
 343     copy("${target_name}__copy_jar") {
 344       sources = [
 345         _input_jar_path,
 346       ]
 347       outputs = [
 348         _output_jar_path,
 349       ]
 350     }
 351   }
 352
 353   action("${target_name}__jar_toc") {
 354     script = "//build/android/gyp/jar_toc.py"
 355     depfile = "$target_gen_dir/$target_name.d"
 356     outputs = [
 357       depfile,
 358       _jar_toc_path,
 359       _jar_toc_path + ".md5.stamp",
 360     ]
 361     inputs = [
 362       _output_jar_path,
 363     ]
 364     args = [
 365       "--depfile",
 366       rebase_path(depfile, root_build_dir),
 367       "--jar-path",
 368       rebase_path(_output_jar_path, root_build_dir),
 369       "--toc-path",
 370       rebase_path(_jar_toc_path, root_build_dir),
 371     ]
 372   }
 373
 374   group(target_name) {
 375     deps = [
 376       ":${target_name}__jar_toc",
 377     ]
 378   }
 379 }
 380
 381 # Packages resources, assets, dex, and native libraries into an apk. Signs and
 382 # zipaligns the apk.
 383 template("create_apk") {
 384   set_sources_assignment_filter([])
 385   if (defined(invoker.testonly)) {
 386     testonly = invoker.testonly
 387   }
 388
 389   _android_manifest = invoker.android_manifest
 390   _base_path = invoker.base_path
 391   _final_apk_path = invoker.apk_path
 392   _resources_zip = invoker.resources_zip
 393   _dex_path = invoker.dex_path
 394   _keystore_path = invoker.keystore_path
 395   _keystore_name = invoker.keystore_name
 396   _keystore_password = invoker.keystore_password
 397   _load_library_from_apk = invoker.load_library_from_apk
 398
 399   _deps = []
 400   if (defined(invoker.deps)) {
 401     _deps = invoker.deps
 402   }
 403
 404   _native_libs_dir = "//build/android/empty/res"
 405   if (defined(invoker.native_libs_dir)) {
 406     _native_libs_dir = invoker.native_libs_dir
 407   }
 408
 409   _asset_location = "//build/android/empty/res"
 410   if (defined(invoker.asset_location)) {
 411     _asset_location = invoker.asset_location
 412   }
 413
 414   _version_code = invoker.version_code
 415   _version_name = invoker.version_name
 416
 417   _base_apk_path = _base_path + ".apk_intermediates"
 418
 419   _resource_packaged_apk_path = _base_apk_path + ".ap_"
 420   _packaged_apk_path = _base_apk_path + ".unfinished.apk"
 421   _shared_resources =
 422       defined(invoker.shared_resources) && invoker.shared_resources
 423
 424   _configuration_name = "Release"
 425   if (is_debug) {
 426     _configuration_name = "Debug"
 427   }
 428
 429   action("${target_name}__package_resources") {
 430     deps = _deps
 431
 432     script = "//build/android/gyp/package_resources.py"
 433     depfile = "${target_gen_dir}/${target_name}.d"
 434     inputs = [
 435       _android_manifest,
 436       _resources_zip,
 437     ]
 438     outputs = [
 439       depfile,
 440       _resource_packaged_apk_path,
 441     ]
 442
 443     _rebased_resources_zips = [ rebase_path(_resources_zip, root_build_dir) ]
 444     args = [
 445       "--depfile",
 446       rebase_path(depfile, root_build_dir),
 447       "--android-sdk",
 448       rebased_android_sdk,
 449       "--android-sdk-tools",
 450       rebased_android_sdk_build_tools,
 451       "--configuration-name=$_configuration_name",
 452       "--android-manifest",
 453       rebase_path(_android_manifest, root_build_dir),
 454       "--version-code",
 455       _version_code,
 456       "--version-name",
 457       _version_name,
 458       "--asset-dir",
 459       rebase_path(_asset_location, root_build_dir),
 460       "--resource-zips=$_rebased_resources_zips",
 461       "--apk-path",
 462       rebase_path(_resource_packaged_apk_path, root_build_dir),
 463     ]
 464
 465     if (_shared_resources) {
 466       args += [ "--shared-resources" ]
 467     }
 468   }
 469
 470   action("${target_name}__package") {
 471     script = "//build/android/gyp/ant.py"
 472     _ant_script = "//build/android/ant/apk-package.xml"
 473
 474     depfile = "$target_gen_dir/$target_name.d"
 475
 476     inputs = [
 477       _dex_path,
 478       _resource_packaged_apk_path,
 479       _ant_script,
 480     ]
 481
 482     outputs = [
 483       depfile,
 484       _packaged_apk_path,
 485     ]
 486
 487     _rebased_emma_jar = ""
 488     _rebased_resource_packaged_apk_path =
 489         rebase_path(_resource_packaged_apk_path, root_build_dir)
 490     _rebased_packaged_apk_path = rebase_path(_packaged_apk_path, root_build_dir)
 491     _rebased_native_libs_dir = rebase_path(_native_libs_dir, root_build_dir)
 492     _rebased_dex_path = rebase_path(_dex_path, root_build_dir)
 493     args = [
 494       "--depfile",
 495       rebase_path(depfile, root_build_dir),
 496       "--",
 497       "-quiet",
 498       "-DANDROID_SDK_ROOT=$rebased_android_sdk_root",
 499       "-DANDROID_SDK_TOOLS=$rebased_android_sdk_build_tools",
 500       "-DRESOURCE_PACKAGED_APK_NAME=$_rebased_resource_packaged_apk_path",
 501       "-DCONFIGURATION_NAME=$_configuration_name",
 502       "-DNATIVE_LIBS_DIR=$_rebased_native_libs_dir",
 503       "-DOUT_DIR=",
 504       "-DUNSIGNED_APK_PATH=$_rebased_packaged_apk_path",
 505       "-DEMMA_INSTRUMENT=0",
 506       "-DEMMA_DEVICE_JAR=$_rebased_emma_jar",
 507       "-DDEX_FILE_PATH=$_rebased_dex_path",
 508       "-Dbasedir=.",
 509       "-buildfile",
 510       rebase_path(_ant_script, root_build_dir),
 511     ]
 512   }
 513
 514   action("${target_name}__finalize") {
 515     script = "//build/android/gyp/finalize_apk.py"
 516     depfile = "$target_gen_dir/$target_name.d"
 517
 518     sources = [
 519       _packaged_apk_path,
 520     ]
 521     inputs = [
 522       _keystore_path,
 523     ]
 524     outputs = [
 525       depfile,
 526       _final_apk_path,
 527     ]
 528
 529     args = [
 530       "--depfile",
 531       rebase_path(depfile, root_build_dir),
 532       "--zipalign-path",
 533       rebase_path(zipalign_path, root_build_dir),
 534       "--unsigned-apk-path",
 535       rebase_path(_packaged_apk_path, root_build_dir),
 536       "--final-apk-path",
 537       rebase_path(_final_apk_path, root_build_dir),
 538       "--key-path",
 539       rebase_path(_keystore_path, root_build_dir),
 540       "--key-name",
 541       _keystore_name,
 542       "--key-passwd",
 543       _keystore_password,
 544     ]
 545     if (_load_library_from_apk) {
 546       _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
 547       inputs += [ _rezip_jar_path ]
 548       args += [
 549         "--load-library-from-zip-file=1",
 550         "--rezip-apk-jar-path",
 551         rebase_path(_rezip_jar_path, root_build_dir),
 552       ]
 553     }
 554   }
 555
 556   group(target_name) {
 557     deps = [
 558       ":${target_name}__finalize",
 559     ]
 560   }
 561 }
 562
 563 template("java_prebuilt_impl") {
 564   set_sources_assignment_filter([])
 565   if (defined(invoker.testonly)) {
 566     testonly = invoker.testonly
 567   }
 568   _supports_android =
 569       defined(invoker.supports_android) && invoker.supports_android
 570
 571   assert(defined(invoker.jar_path))
 572   _base_path = "${target_gen_dir}/$target_name"
 573   _jar_path = _base_path + ".jar"
 574   _build_config = _base_path + ".build_config"
 575
 576   if (_supports_android) {
 577     _dex_path = _base_path + ".dex.jar"
 578   }
 579
 580   _final_deps = []
 581   _template_name = target_name
 582
 583   _final_deps += [ ":${_template_name}__build_config" ]
 584   write_build_config("${_template_name}__build_config") {
 585     type = "java_library"
 586     supports_android = _supports_android
 587     requires_android =
 588         defined(invoker.requires_android) && invoker.requires_android
 589
 590     deps = []
 591     if (defined(invoker.deps)) {
 592       deps += invoker.deps
 593     }
 594     build_config = _build_config
 595     jar_path = _jar_path
 596     if (_supports_android) {
 597       dex_path = _dex_path
 598     }
 599   }
 600
 601   _final_deps += [ ":${_template_name}__process_jar" ]
 602   process_java_prebuilt("${_template_name}__process_jar") {
 603     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 604       proguard_preprocess = true
 605       proguard_config = invoker.proguard_config
 606     }
 607
 608     build_config = _build_config
 609     input_jar_path = invoker.jar_path
 610     output_jar_path = _jar_path
 611   }
 612
 613   if (_supports_android) {
 614     _final_deps += [ ":${_template_name}__dex" ]
 615     dex("${_template_name}__dex") {
 616       sources = [
 617         _jar_path,
 618       ]
 619       output = _dex_path
 620     }
 621   }
 622
 623   group(target_name) {
 624     deps = _final_deps
 625   }
 626 }
 627
 628 # Compiles and jars a set of java files.
 629 #
 630 # Outputs:
 631 #  $jar_path.jar
 632 #  $jar_path.jar.TOC
 633 #
 634 # Variables
 635 #   java_files: List of .java files to compile.
 636 #   java_deps: List of java dependencies. These should all have a .jar output
 637 #     at "${target_gen_dir}/${target_name}.jar.
 638 #   chromium_code: If true, enable extra warnings.
 639 #   srcjar_deps: List of srcjar dependencies. The .java files contained in the
 640 #     dependencies srcjar outputs will be compiled and added to the output jar.
 641 #   jar_path: Use this to explicitly set the output jar path. Defaults to
 642 #     "${target_gen_dir}/${target_name}.jar.
 643 template("compile_java") {
 644   set_sources_assignment_filter([])
 645   if (defined(invoker.testonly)) {
 646     testonly = invoker.testonly
 647   }
 648
 649   assert(defined(invoker.java_files))
 650   assert(defined(invoker.build_config))
 651   assert(defined(invoker.jar_path))
 652
 653   _java_files = invoker.java_files
 654   _final_jar_path = invoker.jar_path
 655   _intermediate_jar_path = "$target_gen_dir/$target_name.initial.jar"
 656
 657   _build_config = invoker.build_config
 658
 659   _jar_excluded_patterns = []
 660   if (defined(invoker.jar_excluded_patterns)) {
 661     _jar_excluded_patterns += invoker.jar_excluded_patterns
 662   }
 663
 664   _chromium_code = false
 665   if (defined(invoker.chromium_code)) {
 666     _chromium_code = invoker.chromium_code
 667   }
 668   _manifest_entries = []
 669   if (defined(invoker.manifest_entries)) {
 670     _manifest_entries = invoker.manifest_entries
 671   }
 672
 673   _srcjar_deps = []
 674   if (defined(invoker.srcjar_deps)) {
 675     _srcjar_deps += invoker.srcjar_deps
 676   }
 677
 678   _java_srcjars = []
 679   if (defined(invoker.srcjars)) {
 680     _java_srcjars = invoker.srcjars
 681   }
 682   foreach(dep, _srcjar_deps) {
 683     _dep_gen_dir = get_label_info(dep, "target_gen_dir")
 684     _dep_name = get_label_info(dep, "name")
 685     _java_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
 686   }
 687
 688   # Mark srcjar_deps as used.
 689   assert(_srcjar_deps == [] || true)
 690
 691   _system_jars = []
 692   if (defined(invoker.android) && invoker.android) {
 693     _system_jars += [ android_sdk_jar ]
 694   }
 695
 696   _rebased_build_config = rebase_path(_build_config, root_build_dir)
 697   _rebased_jar_path = rebase_path(_intermediate_jar_path, root_build_dir)
 698
 699   _template_name = target_name
 700   _final_deps = [ ":${_template_name}__javac" ]
 701   action("${_template_name}__javac") {
 702     script = "//build/android/gyp/javac.py"
 703     depfile = "$target_gen_dir/$target_name.d"
 704     deps = []
 705     outputs = [
 706       depfile,
 707       _intermediate_jar_path,
 708       _intermediate_jar_path + ".md5.stamp",
 709     ]
 710     sources = _java_files + _java_srcjars
 711     inputs = _system_jars + [ _build_config ]
 712
 713     _rebased_system_jars = rebase_path(_system_jars, root_build_dir)
 714     _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
 715     _rebased_depfile = rebase_path(depfile, root_build_dir)
 716     args = [
 717       "--depfile=$_rebased_depfile",
 718       "--classpath=$_rebased_system_jars",
 719       "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 720       "--jar-path=$_rebased_jar_path",
 721       "--java-srcjars=$_rebased_java_srcjars",
 722       "--java-srcjars=@FileArg($_rebased_build_config:javac:srcjars)",
 723       "--jar-excluded-classes=$_jar_excluded_patterns",
 724     ]
 725     foreach(e, _manifest_entries) {
 726       args += [ "--manifest-entry=" + e ]
 727     }
 728     if (_chromium_code) {
 729       args += [ "--chromium-code=1" ]
 730     }
 731
 732     args += rebase_path(_java_files, root_build_dir)
 733   }
 734
 735   _final_deps += [ ":${_template_name}__finish" ]
 736   process_java_prebuilt("${_template_name}__finish") {
 737     build_config = _build_config
 738     input_jar_path = _intermediate_jar_path
 739     output_jar_path = _final_jar_path
 740     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 741       proguard_preprocess = invoker.proguard_preprocess
 742       proguard_config = invoker.proguard_config
 743     }
 744   }
 745
 746   group(target_name) {
 747     deps = _final_deps
 748   }
 749 }
 750
 751 template("java_library_impl") {
 752   set_sources_assignment_filter([])
 753   if (defined(invoker.testonly)) {
 754     testonly = invoker.testonly
 755   }
 756
 757   assert(
 758       defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir) ||
 759       defined(invoker.srcjars) || defined(invoker.srcjar_deps))
 760   _base_path = "$target_gen_dir/$target_name"
 761   _jar_path = _base_path + ".jar"
 762   if (defined(invoker.jar_path)) {
 763     _jar_path = invoker.jar_path
 764   }
 765   _template_name = target_name
 766
 767   _final_deps = []
 768   _final_datadeps = []
 769   if (defined(invoker.datadeps)) {
 770     _final_datadeps = invoker.datadeps
 771   }
 772
 773   _supports_android =
 774       defined(invoker.supports_android) && invoker.supports_android
 775   _requires_android =
 776       defined(invoker.requires_android) && invoker.requires_android
 777
 778   if (_supports_android) {
 779     _dex_path = _base_path + ".dex.jar"
 780     if (defined(invoker.dex_path)) {
 781       _dex_path = invoker.dex_path
 782     }
 783   }
 784
 785   if (defined(invoker.override_build_config)) {
 786     _build_config = invoker.override_build_config
 787   } else {
 788     _build_config = _base_path + ".build_config"
 789     _final_deps += [ ":${_template_name}__build_config" ]
 790     write_build_config("${_template_name}__build_config") {
 791       type = "java_library"
 792       supports_android = _supports_android
 793       requires_android = _requires_android
 794       bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
 795                                invoker.bypass_platform_checks
 796
 797       deps = []
 798       if (defined(invoker.deps)) {
 799         deps += invoker.deps
 800       }
 801
 802       build_config = _build_config
 803       jar_path = _jar_path
 804       if (_supports_android) {
 805         dex_path = _dex_path
 806       }
 807     }
 808   }
 809
 810   _chromium_code = true
 811   if (defined(invoker.chromium_code)) {
 812     _chromium_code = invoker.chromium_code
 813   }
 814
 815   _srcjar_deps = []
 816   if (defined(invoker.srcjar_deps)) {
 817     _srcjar_deps = invoker.srcjar_deps
 818   }
 819
 820   _srcjars = []
 821   if (defined(invoker.srcjars)) {
 822     _srcjars = invoker.srcjars
 823   }
 824
 825   _java_files = []
 826   if (defined(invoker.java_files)) {
 827     _java_files = invoker.java_files
 828   } else if (defined(invoker.DEPRECATED_java_in_dir)) {
 829     _src_dir = invoker.DEPRECATED_java_in_dir + "/src"
 830     _src_dir_exists = exec_script("//build/dir_exists.py",
 831                                   [ rebase_path(_src_dir, root_build_dir) ],
 832                                   "string")
 833     assert(_src_dir_exists == "False",
 834            "In GN, java_in_dir should be the fully specified java directory " +
 835                "(i.e. including the trailing \"/src\")")
 836
 837     _java_files_build_rel = exec_script(
 838             "//build/android/gyp/find.py",
 839             [
 840               "--pattern",
 841               "*.java",
 842               rebase_path(invoker.DEPRECATED_java_in_dir, root_build_dir),
 843             ],
 844             "list lines")
 845     _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
 846   }
 847   assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
 848
 849   _final_deps += [ ":${_template_name}__compile_java" ]
 850   compile_java("${_template_name}__compile_java") {
 851     jar_path = _jar_path
 852     build_config = _build_config
 853     java_files = _java_files
 854     srcjar_deps = _srcjar_deps
 855     srcjars = _srcjars
 856     chromium_code = _chromium_code
 857     android = _requires_android
 858
 859     if (defined(invoker.jar_excluded_patterns)) {
 860       jar_excluded_patterns = invoker.jar_excluded_patterns
 861     }
 862     if (defined(invoker.proguard_preprocess)) {
 863       proguard_preprocess = invoker.proguard_preprocess
 864     }
 865     if (defined(invoker.proguard_config)) {
 866       proguard_config = invoker.proguard_config
 867     }
 868     if (defined(invoker.dist_jar_path)) {
 869       dist_jar_path = invoker.dist_jar_path
 870     }
 871     if (defined(invoker.manifest_entries)) {
 872       manifest_entries = invoker.manifest_entries
 873     }
 874   }
 875
 876   if (defined(invoker.main_class)) {
 877     _final_deps += [ ":${_template_name}__binary_script" ]
 878     action("${_template_name}__binary_script") {
 879       script = "//build/android/gyp/create_java_binary_script.py"
 880       depfile = "$target_gen_dir/$target_name.d"
 881       java_script = "$root_build_dir/bin/$_template_name"
 882       inputs = [
 883         _build_config,
 884       ]
 885       outputs = [
 886         depfile,
 887         java_script,
 888       ]
 889       _rebased_build_config = rebase_path(_build_config, root_build_dir)
 890       args = [
 891         "--depfile",
 892         rebase_path(depfile, root_build_dir),
 893         "--output",
 894         rebase_path(java_script, root_build_dir),
 895         "--classpath=@FileArg($_rebased_build_config:java:full_classpath)",
 896         "--jar-path",
 897         rebase_path(_jar_path, root_build_dir),
 898         "--main-class",
 899         invoker.main_class,
 900       ]
 901     }
 902   }
 903
 904   if (_supports_android) {
 905     if (defined(invoker.chromium_code) && invoker.chromium_code) {
 906       _android_manifest = "//build/android/AndroidManifest.xml"
 907       if (defined(invoker.android_manifest)) {
 908         _android_manifest = invoker.android_manifest
 909       }
 910
 911       _final_datadeps += [ ":${_template_name}__lint" ]
 912       android_lint("${_template_name}__lint") {
 913         android_manifest = _android_manifest
 914         jar_path = _jar_path
 915         java_files = _java_files
 916       }
 917     }
 918
 919     _final_deps += [ ":${_template_name}__dex" ]
 920     dex("${_template_name}__dex") {
 921       sources = [
 922         _jar_path,
 923       ]
 924       output = _dex_path
 925     }
 926   }
 927
 928   group(target_name) {
 929     if (defined(invoker.visibility)) {
 930       visibility = invoker.visibility
 931     }
 932     deps = _final_deps
 933     datadeps = _final_datadeps
 934   }
 935 }
 936
 937 # Runs process_resources.py
 938 template("process_resources") {
 939   set_sources_assignment_filter([])
 940   if (defined(invoker.testonly)) {
 941     testonly = invoker.testonly
 942   }
 943
 944   zip_path = invoker.zip_path
 945   srcjar_path = invoker.srcjar_path
 946   build_config = invoker.build_config
 947   resource_dirs = invoker.resource_dirs
 948   android_manifest = invoker.android_manifest
 949
 950   non_constant_id = true
 951   if (defined(invoker.generate_constant_ids) && invoker.generate_constant_ids) {
 952     non_constant_id = false
 953   }
 954
 955   action(target_name) {
 956     script = "//build/android/gyp/process_resources.py"
 957
 958     depfile = "$target_gen_dir/$target_name.d"
 959     outputs = [
 960       depfile,
 961       zip_path,
 962       srcjar_path,
 963     ]
 964
 965     sources_build_rel = exec_script("//build/android/gyp/find.py",
 966                                     rebase_path(resource_dirs, root_build_dir),
 967                                     "list lines")
 968     sources = rebase_path(sources_build_rel, ".", root_build_dir)
 969
 970     inputs = [
 971       build_config,
 972       android_manifest,
 973     ]
 974
 975     rebase_resource_dirs = rebase_path(resource_dirs, root_build_dir)
 976     rebase_build_config = rebase_path(build_config, root_build_dir)
 977     args = [
 978       "--depfile",
 979       rebase_path(depfile, root_build_dir),
 980       "--android-sdk",
 981       rebase_path(android_sdk, root_build_dir),
 982       "--android-sdk-tools",
 983       rebase_path(android_sdk_build_tools, root_build_dir),
 984       "--android-manifest",
 985       rebase_path(android_manifest, root_build_dir),
 986       "--resource-dirs=$rebase_resource_dirs",
 987       "--srcjar-out",
 988       rebase_path(srcjar_path, root_build_dir),
 989       "--resource-zip-out",
 990       rebase_path(zip_path, root_build_dir),
 991       "--dependencies-res-zips=@FileArg($rebase_build_config:resources:dependency_zips)",
 992       "--extra-res-packages=@FileArg($rebase_build_config:resources:extra_package_names)",
 993     ]
 994
 995     if (non_constant_id) {
 996       args += [ "--non-constant-id" ]
 997     }
 998
 999     if (defined(invoker.custom_package)) {
1000       args += [
1001         "--custom-package",
1002         invoker.custom_package,
1003       ]
1004     }
1005
1006     if (defined(invoker.v14_verify_only) && invoker.v14_verify_only) {
1007       args += [ "--v14-verify-only" ]
1008     }
1009
1010     if (defined(invoker.shared_resources) && invoker.shared_resources) {
1011       args += [ "--shared-resources" ]
1012     }
1013
1014     if (defined(invoker.all_resources_zip_path)) {
1015       all_resources_zip = invoker.all_resources_zip_path
1016       outputs += [ all_resources_zip ]
1017       args += [
1018         "--all-resources-zip-out",
1019         rebase_path(all_resources_zip, root_build_dir),
1020       ]
1021     }
1022
1023     if (defined(invoker.args)) {
1024       args += invoker.args
1025     }
1026   }
1027 }
1028
1029 template("copy_ex") {
1030   set_sources_assignment_filter([])
1031   if (defined(invoker.testonly)) {
1032     testonly = invoker.testonly
1033   }
1034
1035   action(target_name) {
1036     script = "//build/android/gyp/copy_ex.py"
1037
1038     if (defined(invoker.deps)) {
1039       deps = invoker.deps
1040     }
1041
1042     sources = []
1043     if (defined(invoker.sources)) {
1044       sources += invoker.sources
1045     }
1046
1047     inputs = []
1048     if (defined(invoker.inputs)) {
1049       inputs += invoker.inputs
1050     }
1051
1052     depfile = "$target_gen_dir/$target_name.d"
1053     outputs = [
1054       depfile,
1055     ]
1056
1057     args = [
1058       "--depfile",
1059       rebase_path(depfile, root_build_dir),
1060       "--dest",
1061       rebase_path(invoker.dest, root_build_dir),
1062     ]
1063     rebased_sources = rebase_path(sources, root_build_dir)
1064     args += [ "--files=$rebased_sources" ]
1065
1066     if (defined(invoker.clear_dir) && invoker.clear_dir) {
1067       args += [ "--clear" ]
1068     }
1069
1070     if (defined(invoker.args)) {
1071       args += invoker.args
1072     }
1073   }
1074 }
1075
1076 # Produces a single .dex.jar out of a set of Java dependencies.
1077 template("deps_dex") {
1078   set_sources_assignment_filter([])
1079   build_config = "$target_gen_dir/${target_name}.build_config"
1080   write_build_config("${target_name}__build_config") {
1081     type = "deps_dex"
1082     deps = invoker.deps
1083
1084     build_config = build_config
1085     dex_path = invoker.dex_path
1086   }
1087
1088   rebased_build_config = rebase_path(build_config, root_build_dir)
1089   dex(target_name) {
1090     inputs = [
1091       build_config,
1092     ]
1093     output = invoker.dex_path
1094     dex_arg_key = "${rebased_build_config}:final_dex:dependency_dex_files"
1095     args = [ "--inputs=@FileArg($dex_arg_key)" ]
1096     if (defined(invoker.excluded_jars)) {
1097       excluded_jars = rebase_path(invoker.excluded_jars, root_build_dir)
1098       args += [ "--excluded-paths=${excluded_jars}" ]
1099     }
1100   }
1101 }