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