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 import("//third_party/ijar/ijar.gni")
   7
   8 assert(is_android)
   9
  10 rebased_android_sdk = rebase_path(android_sdk, root_build_dir)
  11 rebased_android_sdk_root = rebase_path(android_sdk_root, root_build_dir)
  12 rebased_android_sdk_build_tools =
  13     rebase_path(android_sdk_build_tools, root_build_dir)
  14
  15 android_sdk_jar = "$android_sdk/android.jar"
  16 rebased_android_sdk_jar = rebase_path(android_sdk_jar, root_build_dir)
  17 android_aapt_path = "$rebased_android_sdk_build_tools/aapt"
  18
  19 android_configuration_name = "Release"
  20 if (is_debug) {
  21   android_configuration_name = "Debug"
  22 }
  23
  24 template("android_lint") {
  25   set_sources_assignment_filter([])
  26
  27   jar_path = invoker.jar_path
  28   android_manifest = invoker.android_manifest
  29   java_files = invoker.java_files
  30   base_path = "$target_gen_dir/$target_name"
  31
  32   action(target_name) {
  33     forward_variables_from(invoker,
  34                            [
  35                              "deps",
  36                              "data_deps",
  37                              "public_deps",
  38                              "testonly",
  39                            ])
  40     script = "//build/android/gyp/lint.py"
  41     result_path = base_path + "/result.xml"
  42     config_path = base_path + "/config.xml"
  43     suppressions_file = "//build/android/lint/suppressions.xml"
  44     inputs = [
  45                suppressions_file,
  46                android_manifest,
  47                jar_path,
  48              ] + java_files
  49
  50     outputs = [
  51       config_path,
  52       result_path,
  53     ]
  54
  55     rebased_java_files = rebase_path(java_files, root_build_dir)
  56
  57     args = [
  58       "--lint-path=$rebased_android_sdk_root/tools/lint",
  59       "--config-path",
  60       rebase_path(suppressions_file, root_build_dir),
  61       "--manifest-path",
  62       rebase_path(android_manifest, root_build_dir),
  63       "--product-dir=.",
  64       "--jar-path",
  65       rebase_path(jar_path, root_build_dir),
  66       "--processed-config-path",
  67       rebase_path(config_path, root_build_dir),
  68       "--result-path",
  69       rebase_path(result_path, root_build_dir),
  70       "--java-files=$rebased_java_files",
  71       "--enable",
  72     ]
  73   }
  74 }
  75
  76 template("findbugs") {
  77   jar_path = invoker.jar_path
  78
  79   build_config = invoker.build_config
  80
  81   action(target_name) {
  82     forward_variables_from(invoker,
  83                            [
  84                              "deps",
  85                              "testonly",
  86                            ])
  87     script = "//build/android/findbugs_diff.py"
  88     depfile = "$target_gen_dir/$target_name.d"
  89     result_path = "$target_gen_dir/$target_name/result.xml"
  90     exclusions_file = "//build/android/findbugs_filter/findbugs_exclude.xml"
  91
  92     rebased_build_config = rebase_path(build_config, root_build_dir)
  93
  94     inputs = [
  95       "//build/android/pylib/utils/findbugs.py",
  96       exclusions_file,
  97       jar_path,
  98     ]
  99
 100     outputs = [
 101       depfile,
 102       result_path,
 103     ]
 104
 105     args = [
 106       "--depfile",
 107       rebase_path(depfile, root_build_dir),
 108       "--exclude",
 109       rebase_path(exclusions_file, root_build_dir),
 110       "--auxclasspath-gyp",
 111       "@FileArg($rebased_build_config:javac:classpath)",
 112       "--output-file",
 113       rebase_path(result_path, root_build_dir),
 114       rebase_path(jar_path, root_build_dir),
 115     ]
 116
 117     if (findbugs_verbose) {
 118       args += [ "-vv" ]
 119     }
 120   }
 121 }
 122
 123 # Generates a script in the output bin.java directory to run a java binary.
 124 template("java_binary_script") {
 125   set_sources_assignment_filter([])
 126   forward_variables_from(invoker, [ "testonly" ])
 127
 128   _main_class = invoker.main_class
 129   _build_config = invoker.build_config
 130   _jar_path = invoker.jar_path
 131   _script_name = invoker.script_name
 132
 133   action(target_name) {
 134     script = "//build/android/gyp/create_java_binary_script.py"
 135     depfile = "$target_gen_dir/$_script_name.d"
 136     java_script = "$root_build_dir/bin/$_script_name"
 137     inputs = [
 138       _build_config,
 139     ]
 140     outputs = [
 141       depfile,
 142       java_script,
 143     ]
 144     forward_variables_from(invoker, [ "deps" ])
 145     _rebased_build_config = rebase_path(_build_config, root_build_dir)
 146     args = [
 147       "--depfile",
 148       rebase_path(depfile, root_build_dir),
 149       "--output",
 150       rebase_path(java_script, root_build_dir),
 151       "--classpath=@FileArg($_rebased_build_config:java:full_classpath)",
 152       "--jar-path",
 153       rebase_path(_jar_path, root_build_dir),
 154       "--main-class",
 155       _main_class,
 156     ]
 157   }
 158 }
 159
 160 template("dex") {
 161   set_sources_assignment_filter([])
 162
 163   assert(defined(invoker.output))
 164   action(target_name) {
 165     forward_variables_from(invoker,
 166                            [
 167                              "deps",
 168                              "inputs",
 169                              "sources",
 170                              "testonly",
 171                            ])
 172     script = "//build/android/gyp/dex.py"
 173     depfile = "$target_gen_dir/$target_name.d"
 174     outputs = [
 175       depfile,
 176       invoker.output,
 177     ]
 178
 179     rebased_output = rebase_path(invoker.output, root_build_dir)
 180
 181     args = [
 182       "--depfile",
 183       rebase_path(depfile, root_build_dir),
 184       "--android-sdk-tools",
 185       rebased_android_sdk_build_tools,
 186       "--dex-path",
 187       rebased_output,
 188     ]
 189
 190     if (defined(invoker.no_locals) && invoker.no_locals) {
 191       args += [ "--no-locals=1" ]
 192     }
 193
 194     if (defined(invoker.args)) {
 195       args += invoker.args
 196     }
 197
 198     if (defined(invoker.sources)) {
 199       args += rebase_path(invoker.sources, root_build_dir)
 200     }
 201   }
 202 }
 203
 204 # Creates a zip archive of the inputs.
 205 # If base_dir is provided, the archive paths will be relative to it.
 206 template("zip") {
 207   set_sources_assignment_filter([])
 208   assert(defined(invoker.inputs))
 209   assert(defined(invoker.output))
 210
 211   rebase_inputs = rebase_path(invoker.inputs, root_build_dir)
 212   rebase_output = rebase_path(invoker.output, root_build_dir)
 213   action(target_name) {
 214     forward_variables_from(invoker,
 215                            [
 216                              "data_deps",
 217                              "deps",
 218                              "public_deps",
 219                              "inputs",
 220                              "testonly",
 221                              "visibility",
 222                            ])
 223     script = "//build/android/gn/zip.py"
 224     depfile = "$target_gen_dir/$target_name.d"
 225     outputs = [
 226       depfile,
 227       invoker.output,
 228     ]
 229     args = [
 230       "--depfile",
 231       rebase_path(depfile, root_build_dir),
 232       "--inputs=$rebase_inputs",
 233       "--output=$rebase_output",
 234     ]
 235     if (defined(invoker.base_dir)) {
 236       args += [
 237         "--base-dir",
 238         rebase_path(invoker.base_dir, root_build_dir),
 239       ]
 240     }
 241   }
 242 }
 243
 244 # Write the target's .build_config file. This is a json file that contains a
 245 # dictionary of information about how to build this target (things that
 246 # require knowledge about this target's dependencies and cannot be calculated
 247 # at gn-time). There is a special syntax to add a value in that dictionary to
 248 # an action/action_foreachs args:
 249 #   --python-arg=@FileArg($rebased_build_config_path:key0:key1)
 250 # At runtime, such an arg will be replaced by the value in the build_config.
 251 # See build/android/gyp/write_build_config.py and
 252 # build/android/gyp/util/build_utils.py:ExpandFileArgs
 253 template("write_build_config") {
 254   set_sources_assignment_filter([])
 255
 256   assert(defined(invoker.type))
 257   assert(defined(invoker.build_config))
 258
 259   type = invoker.type
 260   build_config = invoker.build_config
 261
 262   assert(type == "android_apk" || type == "java_library" ||
 263          type == "android_resources" || type == "deps_dex")
 264
 265   action(target_name) {
 266     deps = []
 267     forward_variables_from(invoker,
 268                            [
 269                              "deps",
 270                              "testonly",
 271                              "visibility",
 272                            ])
 273
 274     script = "//build/android/gyp/write_build_config.py"
 275     depfile = "$target_gen_dir/$target_name.d"
 276     inputs = []
 277
 278     possible_deps_configs = []
 279     foreach(d, deps) {
 280       dep_gen_dir = get_label_info(d, "target_gen_dir")
 281       dep_name = get_label_info(d, "name")
 282       possible_deps_configs += [ "$dep_gen_dir/$dep_name.build_config" ]
 283     }
 284     rebase_possible_deps_configs =
 285         rebase_path(possible_deps_configs, root_build_dir)
 286
 287     outputs = [
 288       depfile,
 289       build_config,
 290     ]
 291
 292     args = [
 293       "--type",
 294       type,
 295       "--depfile",
 296       rebase_path(depfile, root_build_dir),
 297       "--possible-deps-configs=$rebase_possible_deps_configs",
 298       "--build-config",
 299       rebase_path(build_config, root_build_dir),
 300     ]
 301
 302     is_java_library = type == "java_library"
 303     is_apk = type == "android_apk"
 304     is_android_resources = type == "android_resources"
 305     is_deps_dex = type == "deps_dex"
 306
 307     supports_android = is_apk || is_android_resources || is_deps_dex ||
 308                        (is_java_library && defined(invoker.supports_android) &&
 309                         invoker.supports_android)
 310     requires_android = is_apk || is_android_resources || is_deps_dex ||
 311                        (is_java_library && defined(invoker.requires_android) &&
 312                         invoker.requires_android)
 313
 314     assert(!requires_android || supports_android,
 315            "requires_android requires" + " supports_android")
 316
 317     # Mark these variables as used.
 318     assert(is_java_library || true)
 319     assert(is_apk || true)
 320     assert(is_android_resources || true)
 321     assert(is_deps_dex || true)
 322
 323     if (is_java_library || is_apk) {
 324       args += [
 325         "--jar-path",
 326         rebase_path(invoker.jar_path, root_build_dir),
 327       ]
 328     }
 329
 330     if (is_apk || is_deps_dex || (is_java_library && supports_android)) {
 331       args += [
 332         "--dex-path",
 333         rebase_path(invoker.dex_path, root_build_dir),
 334       ]
 335     }
 336     if (supports_android) {
 337       args += [ "--supports-android" ]
 338     }
 339     if (requires_android) {
 340       args += [ "--requires-android" ]
 341     }
 342     if (defined(invoker.bypass_platform_checks) &&
 343         invoker.bypass_platform_checks) {
 344       args += [ "--bypass-platform-checks" ]
 345     }
 346
 347     if (defined(invoker.apk_under_test)) {
 348       deps += [ invoker.apk_under_test ]
 349       apk_under_test_gen_dir =
 350           get_label_info(invoker.apk_under_test, "target_gen_dir")
 351       apk_under_test_name = get_label_info(invoker.apk_under_test, "name")
 352       apk_under_test_config =
 353           "$apk_under_test_gen_dir/$apk_under_test_name.build_config"
 354       args += [
 355         "--tested-apk-config",
 356         rebase_path(apk_under_test_config, root_build_dir),
 357       ]
 358     }
 359
 360     if (is_android_resources || is_apk) {
 361       assert(defined(invoker.resources_zip))
 362       args += [
 363         "--resources-zip",
 364         rebase_path(invoker.resources_zip, root_build_dir),
 365       ]
 366       if (defined(invoker.android_manifest)) {
 367         inputs += [ invoker.android_manifest ]
 368         args += [
 369           "--android-manifest",
 370           rebase_path(invoker.android_manifest, root_build_dir),
 371         ]
 372       } else {
 373         assert(!is_apk, "apk build configs require an android_manifest")
 374       }
 375       if (defined(invoker.custom_package)) {
 376         args += [
 377           "--package-name",
 378           invoker.custom_package,
 379         ]
 380       }
 381       if (defined(invoker.r_text)) {
 382         args += [
 383           "--r-text",
 384           rebase_path(invoker.r_text, root_build_dir),
 385         ]
 386       }
 387     }
 388
 389     if (is_apk) {
 390       if (defined(invoker.native_libs)) {
 391         inputs += invoker.native_libs
 392         rebased_native_libs = rebase_path(invoker.native_libs, root_build_dir)
 393         rebased_android_readelf = rebase_path(android_readelf, root_build_dir)
 394         args += [
 395           "--native-libs=$rebased_native_libs",
 396           "--readelf-path=$rebased_android_readelf",
 397         ]
 398       }
 399     }
 400
 401     if (defined(invoker.srcjar)) {
 402       args += [
 403         "--srcjar",
 404         rebase_path(invoker.srcjar, root_build_dir),
 405       ]
 406     }
 407   }
 408 }
 409
 410 template("process_java_prebuilt") {
 411   set_sources_assignment_filter([])
 412   forward_variables_from(invoker, [ "testonly" ])
 413
 414   _input_jar_path = invoker.input_jar_path
 415   _output_jar_path = invoker.output_jar_path
 416   _output_ijar_path = get_path_info(_output_jar_path, "dir") + "/" +
 417                       get_path_info(_output_jar_path, "name") + ".interface.jar"
 418
 419   assert(invoker.build_config != "")
 420
 421   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 422     _proguard_jar_path = "//third_party/proguard/lib/proguard.jar"
 423     _proguard_config_path = invoker.proguard_config
 424     _build_config = invoker.build_config
 425     _rebased_build_config = rebase_path(_build_config, root_build_dir)
 426     _output_jar_target = "${target_name}__proguard_process"
 427     action(_output_jar_target) {
 428       forward_variables_from(invoker,
 429                              [
 430                                "data_deps",
 431                                "deps",
 432                                "public_deps",
 433                              ])
 434       script = "//build/android/gyp/proguard.py"
 435       inputs = [
 436         android_sdk_jar,
 437         _proguard_jar_path,
 438         _build_config,
 439         _input_jar_path,
 440         _proguard_config_path,
 441       ]
 442       depfile = "${target_gen_dir}/${target_name}.d"
 443       outputs = [
 444         depfile,
 445         _output_jar_path,
 446       ]
 447       args = [
 448         "--depfile",
 449         rebase_path(depfile, root_build_dir),
 450         "--proguard-path",
 451         rebase_path(_proguard_jar_path, root_build_dir),
 452         "--input-path",
 453         rebase_path(_input_jar_path, root_build_dir),
 454         "--output-path",
 455         rebase_path(_output_jar_path, root_build_dir),
 456         "--proguard-config",
 457         rebase_path(_proguard_config_path, root_build_dir),
 458         "--classpath",
 459         rebased_android_sdk_jar,
 460         "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 461       ]
 462     }
 463   } else {
 464     _output_jar_target = "${target_name}__copy_jar"
 465     copy(_output_jar_target) {
 466       forward_variables_from(invoker,
 467                              [
 468                                "data_deps",
 469                                "deps",
 470                                "public_deps",
 471                              ])
 472       sources = [
 473         _input_jar_path,
 474       ]
 475       outputs = [
 476         _output_jar_path,
 477       ]
 478     }
 479   }
 480
 481   generate_interface_jar("${target_name}__ijar") {
 482     input_jar = _output_jar_path
 483     output_jar = _output_ijar_path
 484     deps = [
 485       ":$_output_jar_target",
 486     ]
 487   }
 488
 489   group(target_name) {
 490     forward_variables_from(invoker, [ "visibility" ])
 491     public_deps = [
 492       ":${target_name}__ijar",
 493       ":$_output_jar_target",
 494     ]
 495   }
 496 }
 497
 498 # Creates an unsigned .apk.
 499 #
 500 # Variables
 501 #   deps: Specifies the dependencies of this target.
 502 #   dex_path: Path to classes.dex file to include (optional).
 503 #   resource_packaged_apk_path: Path to .ap_ to use.
 504 #   output_apk_path: Output path for the generated .apk.
 505 #   native_libs_dir: Directory containing native libraries.
 506 template("package_apk") {
 507   action(target_name) {
 508     forward_variables_from(invoker,
 509                            [
 510                              "deps",
 511                              "data_deps",
 512                              "public_deps",
 513                              "testonly",
 514                            ])
 515     script = "//build/android/gyp/ant.py"
 516     _ant_script = "//build/android/ant/apk-package.xml"
 517
 518     depfile = "$target_gen_dir/$target_name.d"
 519
 520     inputs = [
 521       invoker.resource_packaged_apk_path,
 522       _ant_script,
 523     ]
 524     if (defined(invoker.dex_path)) {
 525       inputs += [ invoker.dex_path ]
 526     }
 527
 528     outputs = [
 529       depfile,
 530       invoker.output_apk_path,
 531     ]
 532
 533     _rebased_emma_jar = ""
 534     _rebased_resource_packaged_apk_path =
 535         rebase_path(invoker.resource_packaged_apk_path, root_build_dir)
 536     _rebased_packaged_apk_path =
 537         rebase_path(invoker.output_apk_path, root_build_dir)
 538     _rebased_native_libs_dir =
 539         rebase_path(invoker.native_libs_dir, root_build_dir)
 540     args = [
 541       "--depfile",
 542       rebase_path(depfile, root_build_dir),
 543       "--",
 544       "-quiet",
 545       "-DANDROID_SDK_ROOT=$rebased_android_sdk_root",
 546       "-DANDROID_SDK_TOOLS=$rebased_android_sdk_build_tools",
 547       "-DRESOURCE_PACKAGED_APK_NAME=$_rebased_resource_packaged_apk_path",
 548       "-DCONFIGURATION_NAME=$android_configuration_name",
 549       "-DNATIVE_LIBS_DIR=$_rebased_native_libs_dir",
 550       "-DOUT_DIR=",
 551       "-DUNSIGNED_APK_PATH=$_rebased_packaged_apk_path",
 552       "-DEMMA_INSTRUMENT=0",
 553       "-DEMMA_DEVICE_JAR=$_rebased_emma_jar",
 554       "-Dbasedir=.",
 555       "-buildfile",
 556       rebase_path(_ant_script, root_build_dir),
 557     ]
 558     if (defined(invoker.dex_path)) {
 559       _rebased_dex_path = rebase_path(invoker.dex_path, root_build_dir)
 560       args += [
 561         "-DDEX_FILE_PATH=$_rebased_dex_path",
 562         "-DHAS_CODE=true",
 563       ]
 564     } else {
 565       args += [ "-DHAS_CODE=false" ]
 566     }
 567   }
 568 }
 569
 570 # Signs & zipaligns an apk.
 571 #
 572 # Variables
 573 #   input_apk_path: Path of the .apk to be finalized.
 574 #   output_apk_path: Output path for the generated .apk.
 575 #   keystore_path: Path to keystore to use for signing.
 576 #   keystore_name: Key alias to use.
 577 #   keystore_password: Keystore password.
 578 #   rezip_apk: Whether to add crazy-linker alignment.
 579 template("finalize_apk") {
 580   action(target_name) {
 581     script = "//build/android/gyp/finalize_apk.py"
 582     depfile = "$target_gen_dir/$target_name.d"
 583     forward_variables_from(invoker,
 584                            [
 585                              "deps",
 586                              "data_deps",
 587                              "public_deps",
 588                              "testonly",
 589                            ])
 590
 591     sources = [
 592       invoker.input_apk_path,
 593     ]
 594     inputs = [
 595       invoker.keystore_path,
 596     ]
 597     outputs = [
 598       depfile,
 599       invoker.output_apk_path,
 600     ]
 601
 602     args = [
 603       "--depfile",
 604       rebase_path(depfile, root_build_dir),
 605       "--zipalign-path",
 606       rebase_path(zipalign_path, root_build_dir),
 607       "--unsigned-apk-path",
 608       rebase_path(invoker.input_apk_path, root_build_dir),
 609       "--final-apk-path",
 610       rebase_path(invoker.output_apk_path, root_build_dir),
 611       "--key-path",
 612       rebase_path(invoker.keystore_path, root_build_dir),
 613       "--key-name",
 614       invoker.keystore_name,
 615       "--key-passwd",
 616       invoker.keystore_password,
 617     ]
 618     if (defined(invoker.rezip_apk) && invoker.rezip_apk) {
 619       _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
 620       inputs += [ _rezip_jar_path ]
 621       args += [
 622         "--load-library-from-zip=1",
 623         "--rezip-apk-jar-path",
 624         rebase_path(_rezip_jar_path, root_build_dir),
 625       ]
 626     }
 627   }
 628 }
 629
 630 # Packages resources, assets, dex, and native libraries into an apk. Signs and
 631 # zipaligns the apk.
 632 template("create_apk") {
 633   set_sources_assignment_filter([])
 634   forward_variables_from(invoker, [ "testonly" ])
 635
 636   _android_manifest = invoker.android_manifest
 637   _base_path = invoker.base_path
 638   _final_apk_path = invoker.apk_path
 639   _incremental_final_apk_path_helper =
 640       process_file_template(
 641           [ _final_apk_path ],
 642           "{{source_dir}}/{{source_name_part}}_incremental.apk")
 643   _incremental_final_apk_path = _incremental_final_apk_path_helper[0]
 644
 645   if (defined(invoker.resources_zip)) {
 646     _resources_zip = invoker.resources_zip
 647   }
 648   if (defined(invoker.dex_path)) {
 649     _dex_path = invoker.dex_path
 650   }
 651   _load_library_from_apk = invoker.load_library_from_apk
 652
 653   _package_deps = []
 654   if (defined(invoker.deps)) {
 655     _package_deps = invoker.deps
 656   }
 657
 658   _native_libs_dir = "//build/android/empty/res"
 659   if (defined(invoker.native_libs_dir)) {
 660     _native_libs_dir = invoker.native_libs_dir
 661   }
 662
 663   if (defined(invoker.asset_location)) {
 664     _asset_location = invoker.asset_location
 665   }
 666
 667   _version_code = invoker.version_code
 668   _version_name = invoker.version_name
 669
 670   _base_apk_path = _base_path + ".apk_intermediates"
 671
 672   _resource_packaged_apk_path = _base_apk_path + ".ap_"
 673   _packaged_apk_path = _base_apk_path + ".unfinished.apk"
 674   _incremental_packaged_apk_path =
 675       _base_apk_path + "_incremental.unfinished.apk"
 676   _shared_resources =
 677       defined(invoker.shared_resources) && invoker.shared_resources
 678
 679   _keystore_path = invoker.keystore_path
 680   _keystore_name = invoker.keystore_name
 681   _keystore_password = invoker.keystore_password
 682
 683   _split_densities = []
 684   if (defined(invoker.create_density_splits) && invoker.create_density_splits) {
 685     _split_densities = [
 686       "hdpi",
 687       "xhdpi",
 688       "xxhdpi",
 689       "xxxhdpi",
 690       "tvdpi",
 691     ]
 692   }
 693
 694   _split_languages = []
 695   if (defined(invoker.language_splits)) {
 696     _split_languages = invoker.language_splits
 697   }
 698
 699   _package_resources_target_name = "${target_name}__package_resources"
 700   action(_package_resources_target_name) {
 701     deps = _package_deps
 702
 703     script = "//build/android/gyp/package_resources.py"
 704     depfile = "${target_gen_dir}/${target_name}.d"
 705     inputs = [
 706       _android_manifest,
 707     ]
 708     if (defined(_resources_zip)) {
 709       inputs += [ _resources_zip ]
 710     }
 711     outputs = [
 712       depfile,
 713       _resource_packaged_apk_path,
 714     ]
 715
 716     args = [
 717       "--depfile",
 718       rebase_path(depfile, root_build_dir),
 719       "--android-sdk",
 720       rebased_android_sdk,
 721       "--aapt-path",
 722       android_aapt_path,
 723       "--configuration-name=$android_configuration_name",
 724       "--android-manifest",
 725       rebase_path(_android_manifest, root_build_dir),
 726       "--version-code",
 727       _version_code,
 728       "--version-name",
 729       _version_name,
 730       "--apk-path",
 731       rebase_path(_resource_packaged_apk_path, root_build_dir),
 732     ]
 733
 734     if (defined(_asset_location)) {
 735       args += [
 736         "--asset-dir",
 737         rebase_path(_asset_location, root_build_dir),
 738       ]
 739     }
 740     if (defined(_resources_zip)) {
 741       args += [
 742         "--resource-zips",
 743         rebase_path(_resources_zip, root_build_dir),
 744       ]
 745     }
 746     if (_shared_resources) {
 747       args += [ "--shared-resources" ]
 748     }
 749     if (_split_densities != []) {
 750       args += [ "--create-density-splits" ]
 751       foreach(_density, _split_densities) {
 752         outputs += [ "${_resource_packaged_apk_path}_${_density}" ]
 753       }
 754     }
 755     if (_split_languages != []) {
 756       args += [ "--language-splits=$_split_languages" ]
 757       foreach(_language, _split_languages) {
 758         outputs += [ "${_resource_packaged_apk_path}_${_language}" ]
 759       }
 760     }
 761     if (defined(invoker.extensions_to_not_compress)) {
 762       args += [
 763         "--no-compress",
 764         invoker.extensions_to_not_compress,
 765       ]
 766     }
 767   }
 768
 769   package_target = "${target_name}__package"
 770   package_apk(package_target) {
 771     deps = []
 772     forward_variables_from(invoker, [ "deps" ])
 773     deps += [ ":${_package_resources_target_name}" ]
 774
 775     data_deps = [ "//tools/android/md5sum" ]  # Used when deploying APKs
 776
 777     if (defined(_dex_path)) {
 778       dex_path = _dex_path
 779     }
 780     native_libs_dir = _native_libs_dir
 781     output_apk_path = _packaged_apk_path
 782     resource_packaged_apk_path = _resource_packaged_apk_path
 783   }
 784
 785   _incremental_package_target = "${target_name}_incremental__package"
 786   package_apk(_incremental_package_target) {
 787     deps = []
 788     forward_variables_from(invoker, [ "deps" ])
 789     deps += [ ":${_package_resources_target_name}" ]
 790
 791     # TODO(agrieve): Multidex
 792     if (defined(_dex_path)) {
 793       dex_path = _dex_path
 794     }
 795
 796     # TODO(agrieve): Add a placeholder .so for http://crbug.com/384638
 797     native_libs_dir = "//build/android/empty/res"
 798     output_apk_path = _incremental_packaged_apk_path
 799     resource_packaged_apk_path = _resource_packaged_apk_path
 800   }
 801
 802   _finalize_apk_rule_name = "${target_name}__finalize"
 803   finalize_apk(_finalize_apk_rule_name) {
 804     input_apk_path = _packaged_apk_path
 805     output_apk_path = _final_apk_path
 806     keystore_path = _keystore_path
 807     keystore_name = _keystore_name
 808     keystore_password = _keystore_password
 809     rezip_apk = _load_library_from_apk
 810
 811     public_deps = [
 812       # Generator of the _packaged_apk_path this target takes as input.
 813       ":$package_target",
 814     ]
 815   }
 816
 817   _incremental_finalize_apk_rule_name = "${target_name}_incremental__finalize"
 818   finalize_apk(_incremental_finalize_apk_rule_name) {
 819     input_apk_path = _incremental_packaged_apk_path
 820     output_apk_path = _incremental_final_apk_path
 821     keystore_path = _keystore_path
 822     keystore_name = _keystore_name
 823     keystore_password = _keystore_password
 824
 825     public_deps = [
 826       ":$_incremental_package_target",
 827     ]
 828   }
 829
 830   _split_deps = []
 831
 832   template("finalize_split") {
 833     finalize_apk(target_name) {
 834       _config = invoker.split_config
 835       _type = invoker.split_type
 836       input_apk_path = "${_resource_packaged_apk_path}_${_config}"
 837       _output_paths = process_file_template(
 838               [ _final_apk_path ],
 839               "{{source_dir}}/{{source_name_part}}-${_type}-${_config}.apk")
 840       output_apk_path = _output_paths[0]
 841       keystore_path = _keystore_path
 842       keystore_name = _keystore_name
 843       keystore_password = _keystore_password
 844       deps = [
 845         ":${_package_resources_target_name}",
 846       ]
 847     }
 848   }
 849
 850   foreach(_split, _split_densities) {
 851     _split_rule = "${target_name}__finalize_${_split}_split"
 852     finalize_split(_split_rule) {
 853       split_type = "density"
 854       split_config = _split
 855     }
 856     _split_deps += [ ":$_split_rule" ]
 857   }
 858   foreach(_split, _split_languages) {
 859     _split_rule = "${target_name}__finalize_${_split}_split"
 860     finalize_split(_split_rule) {
 861       split_type = "lang"
 862       split_config = _split
 863     }
 864     _split_deps += [ ":$_split_rule" ]
 865   }
 866
 867   group(target_name) {
 868     public_deps = [ ":${_finalize_apk_rule_name}" ] + _split_deps
 869   }
 870   group("${target_name}_incremental") {
 871     public_deps = [ ":${_incremental_finalize_apk_rule_name}" ] + _split_deps
 872   }
 873 }
 874
 875 template("java_prebuilt_impl") {
 876   set_sources_assignment_filter([])
 877   forward_variables_from(invoker, [ "testonly" ])
 878   _supports_android =
 879       defined(invoker.supports_android) && invoker.supports_android
 880
 881   assert(defined(invoker.jar_path))
 882   _base_path = "${target_gen_dir}/$target_name"
 883
 884   # Jar files can be needed at runtime (by Robolectric tests or java binaries),
 885   # so do not put them under gen/.
 886   target_dir_name = get_label_info(":$target_name", "dir")
 887   _jar_path = "$root_out_dir/lib.java$target_dir_name/$target_name.jar"
 888   _build_config = _base_path + ".build_config"
 889
 890   if (_supports_android) {
 891     _dex_path = _base_path + ".dex.jar"
 892   }
 893   _deps = []
 894   if (defined(invoker.deps)) {
 895     _deps = invoker.deps
 896   }
 897   _jar_deps = []
 898   if (defined(invoker.jar_dep)) {
 899     _jar_deps = [ invoker.jar_dep ]
 900   }
 901
 902   _template_name = target_name
 903
 904   build_config_target_name = "${_template_name}__build_config"
 905   process_jar_target_name = "${_template_name}__process_jar"
 906   if (_supports_android) {
 907     dex_target_name = "${_template_name}__dex"
 908   }
 909
 910   write_build_config(build_config_target_name) {
 911     type = "java_library"
 912     supports_android = _supports_android
 913     requires_android =
 914         defined(invoker.requires_android) && invoker.requires_android
 915
 916     deps = _deps
 917     build_config = _build_config
 918     jar_path = _jar_path
 919     if (_supports_android) {
 920       dex_path = _dex_path
 921     }
 922   }
 923
 924   process_java_prebuilt(process_jar_target_name) {
 925     visibility = [ ":$_template_name" ]
 926     if (_supports_android) {
 927       visibility += [ ":$dex_target_name" ]
 928     }
 929
 930     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 931       proguard_preprocess = true
 932       proguard_config = invoker.proguard_config
 933     }
 934
 935     build_config = _build_config
 936     input_jar_path = invoker.jar_path
 937     output_jar_path = _jar_path
 938
 939     deps = [ ":$build_config_target_name" ] + _deps + _jar_deps
 940   }
 941
 942   if (_supports_android) {
 943     dex(dex_target_name) {
 944       sources = [
 945         _jar_path,
 946       ]
 947       output = _dex_path
 948       deps = [ ":$process_jar_target_name" ] + _deps + _jar_deps
 949     }
 950   }
 951
 952   if (defined(invoker.main_class)) {
 953     binary_script_target_name = "${_template_name}__java_binary_script"
 954     java_binary_script(binary_script_target_name) {
 955       build_config = _build_config
 956       jar_path = _jar_path
 957       main_class = invoker.main_class
 958       script_name = _template_name
 959       deps = [
 960         ":$build_config_target_name",
 961       ]
 962     }
 963   }
 964
 965   group(target_name) {
 966     forward_variables_from(invoker, [ "data_deps" ])
 967     deps = [
 968       ":$process_jar_target_name",
 969     ]
 970     if (_supports_android) {
 971       deps += [ ":$dex_target_name" ]
 972     }
 973     data_deps = []
 974     if (defined(invoker.data_deps)) {
 975       data_deps += invoker.data_deps
 976     }
 977     if (defined(invoker.main_class)) {
 978       data_deps += [ ":$binary_script_target_name" ]
 979     }
 980   }
 981 }
 982
 983 # Compiles and jars a set of java files.
 984 #
 985 # Outputs:
 986 #  $jar_path.jar
 987 #  $jar_path.interface.jar
 988 #
 989 # Variables
 990 #   java_files: List of .java files to compile.
 991 #   java_deps: List of java dependencies. These should all have a .jar output
 992 #     at "${target_gen_dir}/${target_name}.jar.
 993 #   chromium_code: If true, enable extra warnings.
 994 #   srcjar_deps: List of srcjar dependencies. The .java files contained in the
 995 #     dependencies srcjar outputs will be compiled and added to the output jar.
 996 #   jar_path: Use this to explicitly set the output jar path. Defaults to
 997 #     "${target_gen_dir}/${target_name}.jar.
 998 template("compile_java") {
 999   set_sources_assignment_filter([])
1000   forward_variables_from(invoker, [ "testonly" ])
1001
1002   assert(defined(invoker.java_files))
1003   assert(defined(invoker.build_config))
1004   assert(defined(invoker.jar_path))
1005
1006   _java_files = invoker.java_files
1007   _final_jar_path = invoker.jar_path
1008   _intermediate_jar_path = "$target_gen_dir/$target_name.initial.jar"
1009
1010   _build_config = invoker.build_config
1011
1012   _jar_excluded_patterns = []
1013   if (defined(invoker.jar_excluded_patterns)) {
1014     _jar_excluded_patterns += invoker.jar_excluded_patterns
1015   }
1016
1017   _chromium_code = false
1018   if (defined(invoker.chromium_code)) {
1019     _chromium_code = invoker.chromium_code
1020   }
1021
1022   _supports_android = true
1023   if (defined(invoker.supports_android)) {
1024     _supports_android = invoker.supports_android
1025   }
1026
1027   _enable_errorprone = use_errorprone_java_compiler
1028   if (!_chromium_code) {
1029     _enable_errorprone = false
1030   } else if (defined(invoker.enable_errorprone)) {
1031     _enable_errorprone = invoker.enable_errorprone
1032   }
1033
1034   _manifest_entries = []
1035   if (defined(invoker.manifest_entries)) {
1036     _manifest_entries = invoker.manifest_entries
1037   }
1038
1039   _srcjar_deps = []
1040   if (defined(invoker.srcjar_deps)) {
1041     _srcjar_deps += invoker.srcjar_deps
1042   }
1043
1044   _java_srcjars = []
1045   if (defined(invoker.srcjars)) {
1046     _java_srcjars = invoker.srcjars
1047   }
1048   foreach(dep, _srcjar_deps) {
1049     _dep_gen_dir = get_label_info(dep, "target_gen_dir")
1050     _dep_name = get_label_info(dep, "name")
1051     _java_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
1052   }
1053
1054   # Mark srcjar_deps as used.
1055   assert(_srcjar_deps == [] || true)
1056
1057   _rebased_build_config = rebase_path(_build_config, root_build_dir)
1058   _rebased_jar_path = rebase_path(_intermediate_jar_path, root_build_dir)
1059
1060   javac_target_name = "${target_name}__javac"
1061   finish_target_name = "${target_name}__finish"
1062   final_target_name = target_name
1063
1064   action(javac_target_name) {
1065     script = "//build/android/gyp/javac.py"
1066     depfile = "$target_gen_dir/$target_name.d"
1067     deps = _srcjar_deps
1068     if (defined(invoker.deps)) {
1069       deps += invoker.deps
1070     }
1071
1072     outputs = [
1073       depfile,
1074       _intermediate_jar_path,
1075       _intermediate_jar_path + ".md5.stamp",
1076     ]
1077     sources = _java_files + _java_srcjars
1078     inputs = [
1079       _build_config,
1080     ]
1081
1082     _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
1083     _rebased_depfile = rebase_path(depfile, root_build_dir)
1084     args = [
1085       "--depfile=$_rebased_depfile",
1086       "--use-ijars",
1087       "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
1088       "--jar-path=$_rebased_jar_path",
1089       "--java-srcjars=$_rebased_java_srcjars",
1090       "--java-srcjars=@FileArg($_rebased_build_config:javac:srcjars)",
1091       "--jar-excluded-classes=$_jar_excluded_patterns",
1092     ]
1093     if (_supports_android) {
1094       deps += [ "//build/android:android_ijar" ]
1095       _android_sdk_ijar = "$root_out_dir/lib.java/android.interface.jar"
1096       inputs += [ _android_sdk_ijar ]
1097       _rebased_android_sdk_ijar = rebase_path(_android_sdk_ijar, root_build_dir)
1098       args += [ "--bootclasspath=$_rebased_android_sdk_ijar" ]
1099     }
1100     foreach(e, _manifest_entries) {
1101       args += [ "--manifest-entry=" + e ]
1102     }
1103     if (_chromium_code) {
1104       args += [ "--chromium-code=1" ]
1105     }
1106     if (_enable_errorprone) {
1107       deps += [ "//third_party/errorprone:chromium_errorprone" ]
1108       args += [
1109         "--use-errorprone-path",
1110         "bin/chromium_errorprone",
1111       ]
1112     }
1113     args += rebase_path(_java_files, root_build_dir)
1114   }
1115
1116   process_java_prebuilt(finish_target_name) {
1117     visibility = [ ":$final_target_name" ]
1118
1119     build_config = _build_config
1120     input_jar_path = _intermediate_jar_path
1121     output_jar_path = _final_jar_path
1122     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
1123       proguard_preprocess = invoker.proguard_preprocess
1124       proguard_config = invoker.proguard_config
1125     }
1126     deps = [
1127       ":$javac_target_name",
1128     ]
1129   }
1130
1131   group(final_target_name) {
1132     forward_variables_from(invoker, [ "visibility" ])
1133     public_deps = [
1134       ":$finish_target_name",
1135     ]
1136   }
1137 }
1138
1139 template("java_library_impl") {
1140   set_sources_assignment_filter([])
1141   forward_variables_from(invoker, [ "testonly" ])
1142
1143   assert(
1144       defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir) ||
1145       defined(invoker.srcjars) || defined(invoker.srcjar_deps))
1146   _base_path = "$target_gen_dir/$target_name"
1147
1148   # Jar files can be needed at runtime (by Robolectric tests or java binaries),
1149   # so do not put them under gen/.
1150   target_dir_name = get_label_info(":$target_name", "dir")
1151   _jar_path = "$root_out_dir/lib.java$target_dir_name/$target_name.jar"
1152   if (defined(invoker.jar_path)) {
1153     _jar_path = invoker.jar_path
1154   }
1155   _template_name = target_name
1156
1157   _final_deps = []
1158   _final_datadeps = []
1159   if (defined(invoker.datadeps)) {
1160     _final_datadeps = invoker.datadeps
1161   }
1162
1163   _supports_android =
1164       defined(invoker.supports_android) && invoker.supports_android
1165   _requires_android =
1166       defined(invoker.requires_android) && invoker.requires_android
1167   assert(_requires_android || true)  # Mark as used.
1168
1169   if (_supports_android) {
1170     _dex_path = _base_path + ".dex.jar"
1171     if (defined(invoker.dex_path)) {
1172       _dex_path = invoker.dex_path
1173     }
1174   }
1175
1176   # Define build_config_deps which will be a list of targets required to
1177   # build the _build_config.
1178   if (defined(invoker.override_build_config)) {
1179     _build_config = invoker.override_build_config
1180
1181     # When a custom build config file is specified, we need to use the deps
1182     # supplied by the invoker any time we reference the build config file.
1183     assert(defined(invoker.deps),
1184            "If you specify a build config file for " +
1185                "java_library_impl($target_name), you should " +
1186                "also specify the target that made it in the deps")
1187     build_config_deps = invoker.deps
1188   } else {
1189     _build_config = _base_path + ".build_config"
1190     build_config_target_name = "${_template_name}__build_config"
1191     build_config_deps = [ ":$build_config_target_name" ]
1192
1193     write_build_config(build_config_target_name) {
1194       forward_variables_from(invoker, [ "deps" ])
1195       type = "java_library"
1196       supports_android = _supports_android
1197       requires_android = _requires_android
1198       bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
1199                                invoker.bypass_platform_checks
1200
1201       build_config = _build_config
1202       jar_path = _jar_path
1203       if (_supports_android) {
1204         dex_path = _dex_path
1205       }
1206     }
1207   }
1208
1209   _chromium_code = true
1210   if (defined(invoker.chromium_code)) {
1211     _chromium_code = invoker.chromium_code
1212   }
1213
1214   _srcjar_deps = []
1215   if (defined(invoker.srcjar_deps)) {
1216     _srcjar_deps = invoker.srcjar_deps
1217   }
1218
1219   _srcjars = []
1220   if (defined(invoker.srcjars)) {
1221     _srcjars = invoker.srcjars
1222   }
1223
1224   _java_files = []
1225   if (defined(invoker.DEPRECATED_java_in_dir)) {
1226     _src_dir = invoker.DEPRECATED_java_in_dir + "/src"
1227     _src_dir_exists = exec_script("//build/dir_exists.py",
1228                                   [ rebase_path(_src_dir, root_build_dir) ],
1229                                   "string")
1230     assert(_src_dir_exists == "False",
1231            "In GN, java_in_dir should be the fully specified java directory " +
1232                "(i.e. including the trailing \"/src\")")
1233
1234     _java_files_build_rel =
1235         exec_script("//build/android/gyp/find.py",
1236                     [
1237                       "--pattern",
1238                       "*.java",
1239                       rebase_path(invoker.DEPRECATED_java_in_dir,
1240                                   root_build_dir),
1241                     ],
1242                     "list lines")
1243     _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
1244   }
1245   if (defined(invoker.java_files)) {
1246     _java_files += invoker.java_files
1247   }
1248   assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
1249
1250   _compile_java_target = "${_template_name}__compile_java"
1251   _final_deps += [ ":$_compile_java_target" ]
1252   compile_java(_compile_java_target) {
1253     forward_variables_from(invoker,
1254                            [
1255                              "dist_jar_path",
1256                              "enable_errorprone",
1257                              "jar_excluded_patterns",
1258                              "manifest_entries",
1259                              "proguard_config",
1260                              "proguard_preprocess",
1261                            ])
1262     jar_path = _jar_path
1263     build_config = _build_config
1264     java_files = _java_files
1265     srcjar_deps = _srcjar_deps
1266     srcjars = _srcjars
1267     chromium_code = _chromium_code
1268     supports_android = _supports_android
1269     deps = build_config_deps
1270   }
1271
1272   if (defined(invoker.main_class)) {
1273     _final_datadeps += [ ":${_template_name}__java_binary_script" ]
1274     java_binary_script("${_template_name}__java_binary_script") {
1275       build_config = _build_config
1276       jar_path = _jar_path
1277       main_class = invoker.main_class
1278       script_name = _template_name
1279       deps = build_config_deps
1280     }
1281   }
1282
1283   if (_supports_android) {
1284     if (defined(invoker.chromium_code) && invoker.chromium_code) {
1285       _android_manifest = "//build/android/AndroidManifest.xml"
1286       if (defined(invoker.android_manifest)) {
1287         _android_manifest = invoker.android_manifest
1288       }
1289
1290       _final_datadeps += [ ":${_template_name}__lint" ]
1291       android_lint("${_template_name}__lint") {
1292         android_manifest = _android_manifest
1293         jar_path = _jar_path
1294         java_files = _java_files
1295         deps = [
1296           ":$_compile_java_target",
1297         ]
1298         if (defined(invoker.deps)) {
1299           deps += invoker.deps
1300         }
1301       }
1302
1303       if (defined(invoker.run_findbugs)) {
1304         run_findbugs = invoker.run_findbugs
1305       }
1306       if (run_findbugs) {
1307         _final_datadeps += [ ":${_template_name}__findbugs" ]
1308         findbugs("${_template_name}__findbugs") {
1309           build_config = _build_config
1310           jar_path = _jar_path
1311           deps = [
1312             ":$_compile_java_target",
1313           ]
1314         }
1315       }
1316     }
1317
1318     _final_deps += [ ":${_template_name}__dex" ]
1319     dex("${_template_name}__dex") {
1320       sources = [
1321         _jar_path,
1322       ]
1323       output = _dex_path
1324       deps = [
1325         ":$_compile_java_target",
1326       ]
1327     }
1328   }
1329
1330   group(target_name) {
1331     forward_variables_from(invoker, [ "visibility" ])
1332     public_deps = _final_deps
1333     data_deps = _final_datadeps
1334   }
1335 }
1336
1337 # Runs process_resources.py
1338 template("process_resources") {
1339   set_sources_assignment_filter([])
1340   forward_variables_from(invoker, [ "testonly" ])
1341
1342   zip_path = invoker.zip_path
1343   srcjar_path = invoker.srcjar_path
1344   r_text_path = invoker.r_text_path
1345   build_config = invoker.build_config
1346   resource_dirs = invoker.resource_dirs
1347   android_manifest = invoker.android_manifest
1348
1349   non_constant_id = true
1350   if (defined(invoker.generate_constant_ids) && invoker.generate_constant_ids) {
1351     non_constant_id = false
1352   }
1353
1354   action(target_name) {
1355     forward_variables_from(invoker,
1356                            [
1357                              "deps",
1358                              "visibility",
1359                            ])
1360     script = "//build/android/gyp/process_resources.py"
1361
1362     depfile = "$target_gen_dir/$target_name.d"
1363     outputs = [
1364       depfile,
1365       zip_path,
1366       srcjar_path,
1367       r_text_path,
1368     ]
1369
1370     sources_build_rel = exec_script("//build/android/gyp/find.py",
1371                                     rebase_path(resource_dirs, root_build_dir),
1372                                     "list lines")
1373     sources = rebase_path(sources_build_rel, ".", root_build_dir)
1374
1375     inputs = [
1376       build_config,
1377       android_manifest,
1378     ]
1379
1380     rebase_resource_dirs = rebase_path(resource_dirs, root_build_dir)
1381     rebase_build_config = rebase_path(build_config, root_build_dir)
1382     args = [
1383       "--depfile",
1384       rebase_path(depfile, root_build_dir),
1385       "--android-sdk",
1386       rebase_path(android_sdk, root_build_dir),
1387       "--aapt-path",
1388       android_aapt_path,
1389       "--android-manifest",
1390       rebase_path(android_manifest, root_build_dir),
1391       "--resource-dirs=$rebase_resource_dirs",
1392       "--srcjar-out",
1393       rebase_path(srcjar_path, root_build_dir),
1394       "--resource-zip-out",
1395       rebase_path(zip_path, root_build_dir),
1396       "--r-text-out",
1397       rebase_path(r_text_path, root_build_dir),
1398       "--dependencies-res-zips=@FileArg($rebase_build_config:resources:dependency_zips)",
1399       "--extra-res-packages=@FileArg($rebase_build_config:resources:extra_package_names)",
1400       "--extra-r-text-files=@FileArg($rebase_build_config:resources:extra_r_text_files)",
1401     ]
1402
1403     if (non_constant_id) {
1404       args += [ "--non-constant-id" ]
1405     }
1406
1407     if (defined(invoker.custom_package)) {
1408       args += [
1409         "--custom-package",
1410         invoker.custom_package,
1411       ]
1412     }
1413
1414     if (defined(invoker.v14_skip) && invoker.v14_skip) {
1415       args += [ "--v14-skip" ]
1416     }
1417
1418     if (defined(invoker.shared_resources) && invoker.shared_resources) {
1419       args += [ "--shared-resources" ]
1420     }
1421
1422     if (defined(invoker.include_all_resources) &&
1423         invoker.include_all_resources) {
1424       args += [ "--include-all-resources" ]
1425     }
1426
1427     if (defined(invoker.all_resources_zip_path)) {
1428       all_resources_zip = invoker.all_resources_zip_path
1429       outputs += [ all_resources_zip ]
1430       args += [
1431         "--all-resources-zip-out",
1432         rebase_path(all_resources_zip, root_build_dir),
1433       ]
1434     }
1435
1436     if (defined(invoker.args)) {
1437       args += invoker.args
1438     }
1439   }
1440 }
1441
1442 template("copy_ex") {
1443   set_sources_assignment_filter([])
1444   action(target_name) {
1445     inputs = []
1446     sources = []
1447     forward_variables_from(invoker,
1448                            [
1449                              "deps",
1450                              "inputs",
1451                              "sources",
1452                              "testonly",
1453                              "visibility",
1454                            ])
1455     script = "//build/android/gyp/copy_ex.py"
1456
1457     depfile = "$target_gen_dir/$target_name.d"
1458     outputs = [
1459       depfile,
1460     ]
1461
1462     args = [
1463       "--depfile",
1464       rebase_path(depfile, root_build_dir),
1465       "--dest",
1466       rebase_path(invoker.dest, root_build_dir),
1467     ]
1468     rebased_sources = rebase_path(sources, root_build_dir)
1469     args += [ "--files=$rebased_sources" ]
1470
1471     if (defined(invoker.clear_dir) && invoker.clear_dir) {
1472       args += [ "--clear" ]
1473     }
1474
1475     if (defined(invoker.args)) {
1476       args += invoker.args
1477     }
1478   }
1479 }
1480
1481 # Produces a single .dex.jar out of a set of Java dependencies.
1482 template("deps_dex") {
1483   set_sources_assignment_filter([])
1484   build_config = "$target_gen_dir/${target_name}.build_config"
1485   build_config_target_name = "${target_name}__build_config"
1486
1487   write_build_config(build_config_target_name) {
1488     forward_variables_from(invoker,
1489                            [
1490                              "deps",
1491                              "dex_path",
1492                            ])
1493     type = "deps_dex"
1494     build_config = build_config
1495   }
1496
1497   rebased_build_config = rebase_path(build_config, root_build_dir)
1498   dex(target_name) {
1499     inputs = [
1500       build_config,
1501     ]
1502     output = invoker.dex_path
1503     dex_arg_key = "${rebased_build_config}:final_dex:dependency_dex_files"
1504     args = [ "--inputs=@FileArg($dex_arg_key)" ]
1505     if (defined(invoker.excluded_jars)) {
1506       excluded_jars = rebase_path(invoker.excluded_jars, root_build_dir)
1507       args += [ "--excluded-paths=${excluded_jars}" ]
1508     }
1509     deps = [
1510       ":$build_config_target_name",
1511     ]
1512   }
1513 }
1514
1515 # Creates an AndroidManifest.xml for an APK split.
1516 template("generate_split_manifest") {
1517   assert(defined(invoker.main_manifest))
1518   assert(defined(invoker.out_manifest))
1519   assert(defined(invoker.split_name))
1520
1521   action(target_name) {
1522     forward_variables_from(invoker,
1523                            [
1524                              "deps",
1525                              "testonly",
1526                            ])
1527     depfile = "$target_gen_dir/$target_name.d"
1528     args = [
1529       "--main-manifest",
1530       rebase_path(invoker.main_manifest, root_build_dir),
1531       "--out-manifest",
1532       rebase_path(invoker.out_manifest, root_build_dir),
1533       "--split",
1534       invoker.split_name,
1535     ]
1536     if (defined(invoker.version_code)) {
1537       args += [
1538         "--version-code",
1539         invoker.version_code,
1540       ]
1541     }
1542     if (defined(invoker.version_name)) {
1543       args += [
1544         "--version-name",
1545         invoker.version_name,
1546       ]
1547     }
1548     if (defined(invoker.has_code)) {
1549       args += [
1550         "--has-code",
1551         invoker.has_code,
1552       ]
1553     }
1554     args += [
1555       "--depfile",
1556       rebase_path(depfile, root_build_dir),
1557     ]
1558
1559     script = "//build/android/gyp/generate_split_manifest.py"
1560     outputs = [
1561       depfile,
1562       invoker.out_manifest,
1563     ]
1564     inputs = [
1565       invoker.main_manifest,
1566     ]
1567   }
1568 }
1569
1570 # Generates a script in the output bin directory which runs the test
1571 # target using the test runner script in build/android/test_runner.py.
1572 template("test_runner_script") {
1573   testonly = true
1574   _test_name = invoker.test_name
1575   _test_type = invoker.test_type
1576
1577   action(target_name) {
1578     script = "//build/android/gyp/create_test_runner_script.py"
1579     depfile = "$target_gen_dir/$target_name.d"
1580
1581     test_runner_args = [
1582       _test_type,
1583       "--output-directory",
1584       rebase_path(root_build_dir, root_build_dir),
1585     ]
1586     if (_test_type == "gtest") {
1587       assert(defined(invoker.test_suite))
1588       test_runner_args += [
1589         "--suite",
1590         invoker.test_suite,
1591       ]
1592     } else if (_test_type == "instrumentation") {
1593       assert(defined(invoker.test_apk))
1594       test_runner_args += [
1595         "--test-apk",
1596         invoker.test_apk,
1597       ]
1598     } else {
1599       assert(false, "Invalid test type: $_test_type.")
1600     }
1601
1602     if (defined(invoker.isolate_file)) {
1603       test_runner_args += [
1604         "--isolate-file-path",
1605         rebase_path(invoker.isolate_file, root_build_dir),
1606       ]
1607     }
1608
1609     generated_script = "$root_build_dir/bin/run_${_test_name}"
1610     outputs = [
1611       depfile,
1612       generated_script,
1613     ]
1614     args = [
1615       "--depfile",
1616       rebase_path(depfile, root_build_dir),
1617       "--script-output-path",
1618       rebase_path(generated_script, root_build_dir),
1619     ]
1620     args += test_runner_args
1621   }
1622 }