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       if (defined(invoker.r_text)) {
 327         args += [
 328           "--r-text",
 329           rebase_path(invoker.r_text, root_build_dir),
 330         ]
 331       }
 332     }
 333
 334     if (is_apk) {
 335       if (defined(invoker.native_libs)) {
 336         inputs += invoker.native_libs
 337         rebased_native_libs = rebase_path(invoker.native_libs, root_build_dir)
 338         rebased_android_readelf = rebase_path(android_readelf, root_build_dir)
 339         args += [
 340           "--native-libs=$rebased_native_libs",
 341           "--readelf-path=$rebased_android_readelf",
 342         ]
 343       }
 344     }
 345
 346     if (defined(invoker.srcjar)) {
 347       args += [
 348         "--srcjar",
 349         rebase_path(invoker.srcjar, root_build_dir),
 350       ]
 351     }
 352   }
 353 }
 354
 355 template("process_java_prebuilt") {
 356   set_sources_assignment_filter([])
 357   if (defined(invoker.testonly)) {
 358     testonly = invoker.testonly
 359   }
 360
 361   _input_jar_path = invoker.input_jar_path
 362   _output_jar_path = invoker.output_jar_path
 363   _jar_toc_path = _output_jar_path + ".TOC"
 364
 365   assert(invoker.build_config != "")
 366
 367   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 368     _proguard_jar_path = "$android_sdk_root/tools/proguard/lib/proguard.jar"
 369     _proguard_config_path = invoker.proguard_config
 370     _build_config = invoker.build_config
 371     _rebased_build_config = rebase_path(_build_config, root_build_dir)
 372     action("${target_name}__proguard_process") {
 373       script = "//build/android/gyp/proguard.py"
 374       inputs = [
 375         android_sdk_jar,
 376         _proguard_jar_path,
 377         _build_config,
 378         _input_jar_path,
 379         _proguard_config_path,
 380       ]
 381       depfile = "${target_gen_dir}/${target_name}.d"
 382       outputs = [
 383         depfile,
 384         _output_jar_path,
 385       ]
 386       args = [
 387         "--depfile",
 388         rebase_path(depfile, root_build_dir),
 389         "--proguard-path",
 390         rebase_path(_proguard_jar_path, root_build_dir),
 391         "--input-path",
 392         rebase_path(_input_jar_path, root_build_dir),
 393         "--output-path",
 394         rebase_path(_output_jar_path, root_build_dir),
 395         "--proguard-config",
 396         rebase_path(_proguard_config_path, root_build_dir),
 397         "--classpath",
 398         rebased_android_sdk_jar,
 399         "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 400       ]
 401     }
 402   } else {
 403     copy("${target_name}__copy_jar") {
 404       sources = [
 405         _input_jar_path,
 406       ]
 407       outputs = [
 408         _output_jar_path,
 409       ]
 410     }
 411   }
 412
 413   action("${target_name}__jar_toc") {
 414     script = "//build/android/gyp/jar_toc.py"
 415     depfile = "$target_gen_dir/$target_name.d"
 416     outputs = [
 417       depfile,
 418       _jar_toc_path,
 419       _jar_toc_path + ".md5.stamp",
 420     ]
 421     inputs = [
 422       _output_jar_path,
 423     ]
 424     args = [
 425       "--depfile",
 426       rebase_path(depfile, root_build_dir),
 427       "--jar-path",
 428       rebase_path(_output_jar_path, root_build_dir),
 429       "--toc-path",
 430       rebase_path(_jar_toc_path, root_build_dir),
 431     ]
 432   }
 433
 434   group(target_name) {
 435     deps = [
 436       ":${target_name}__jar_toc",
 437     ]
 438   }
 439 }
 440
 441 template("finalize_apk") {
 442   action(target_name) {
 443     script = "//build/android/gyp/finalize_apk.py"
 444     depfile = "$target_gen_dir/$target_name.d"
 445
 446     sources = [
 447       invoker.input_apk_path,
 448     ]
 449     inputs = [
 450       invoker.keystore_path,
 451     ]
 452     outputs = [
 453       depfile,
 454       invoker.output_apk_path,
 455     ]
 456
 457     args = [
 458       "--depfile",
 459       rebase_path(depfile, root_build_dir),
 460       "--zipalign-path",
 461       rebase_path(zipalign_path, root_build_dir),
 462       "--unsigned-apk-path",
 463       rebase_path(invoker.input_apk_path, root_build_dir),
 464       "--final-apk-path",
 465       rebase_path(invoker.output_apk_path, root_build_dir),
 466       "--key-path",
 467       rebase_path(invoker.keystore_path, root_build_dir),
 468       "--key-name",
 469       invoker.keystore_name,
 470       "--key-passwd",
 471       invoker.keystore_password,
 472     ]
 473     if (defined(invoker.rezip_apk) && invoker.rezip_apk) {
 474       _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
 475       inputs += [ _rezip_jar_path ]
 476       args += [
 477         "--load-library-from-zip=1",
 478         "--rezip-apk-jar-path",
 479         rebase_path(_rezip_jar_path, root_build_dir),
 480       ]
 481     }
 482   }
 483 }
 484
 485 # Packages resources, assets, dex, and native libraries into an apk. Signs and
 486 # zipaligns the apk.
 487 template("create_apk") {
 488   set_sources_assignment_filter([])
 489   if (defined(invoker.testonly)) {
 490     testonly = invoker.testonly
 491   }
 492
 493   _android_manifest = invoker.android_manifest
 494   _base_path = invoker.base_path
 495   _final_apk_path = invoker.apk_path
 496
 497   if (defined(invoker.resources_zip)) {
 498     _resources_zip = invoker.resources_zip
 499   }
 500   if (defined(invoker.dex_path)) {
 501     _dex_path = invoker.dex_path
 502   }
 503   _load_library_from_apk = invoker.load_library_from_apk
 504
 505   _package_deps = []
 506   if (defined(invoker.deps)) {
 507     _package_deps = invoker.deps
 508   }
 509
 510   _native_libs_dir = "//build/android/empty/res"
 511   if (defined(invoker.native_libs_dir)) {
 512     _native_libs_dir = invoker.native_libs_dir
 513   }
 514
 515   if (defined(invoker.asset_location)) {
 516     _asset_location = invoker.asset_location
 517   }
 518
 519   _version_code = invoker.version_code
 520   _version_name = invoker.version_name
 521
 522   _base_apk_path = _base_path + ".apk_intermediates"
 523
 524   _resource_packaged_apk_path = _base_apk_path + ".ap_"
 525   _packaged_apk_path = _base_apk_path + ".unfinished.apk"
 526   _shared_resources =
 527       defined(invoker.shared_resources) && invoker.shared_resources
 528
 529   _configuration_name = "Release"
 530   if (is_debug) {
 531     _configuration_name = "Debug"
 532   }
 533
 534   _create_density_splits =
 535       defined(invoker.create_density_splits) && invoker.create_density_splits
 536   if (_create_density_splits) {
 537     _split_densities = [
 538       "hdpi",
 539       "xhdpi",
 540       "xxhdpi",
 541       "tvdpi",
 542     ]
 543   }
 544
 545   _package_resources_target_name = "${target_name}__package_resources"
 546   action(_package_resources_target_name) {
 547     deps = _package_deps
 548
 549     script = "//build/android/gyp/package_resources.py"
 550     depfile = "${target_gen_dir}/${target_name}.d"
 551     inputs = [
 552       _android_manifest,
 553     ]
 554     if (defined(_resources_zip)) {
 555       inputs += [ _resources_zip ]
 556     }
 557     outputs = [
 558       depfile,
 559       _resource_packaged_apk_path,
 560     ]
 561
 562     args = [
 563       "--depfile",
 564       rebase_path(depfile, root_build_dir),
 565       "--android-sdk",
 566       rebased_android_sdk,
 567       "--android-sdk-tools",
 568       rebased_android_sdk_build_tools,
 569       "--configuration-name=$_configuration_name",
 570       "--android-manifest",
 571       rebase_path(_android_manifest, root_build_dir),
 572       "--version-code",
 573       _version_code,
 574       "--version-name",
 575       _version_name,
 576       "--apk-path",
 577       rebase_path(_resource_packaged_apk_path, root_build_dir),
 578     ]
 579
 580     if (defined(_asset_location)) {
 581       args += [
 582         "--asset-dir",
 583         rebase_path(_asset_location, root_build_dir),
 584       ]
 585     }
 586     if (defined(_resources_zip)) {
 587       args += [
 588         "--resource-zips",
 589         rebase_path(_resources_zip, root_build_dir),
 590       ]
 591     }
 592     if (_shared_resources) {
 593       args += [ "--shared-resources" ]
 594     }
 595     if (_create_density_splits) {
 596       args += [ "--create-density-splits" ]
 597       foreach(_density, _split_densities) {
 598         outputs += [ "${_resource_packaged_apk_path}-${_density}" ]
 599       }
 600     }
 601   }
 602
 603   action("${target_name}__package") {
 604     script = "//build/android/gyp/ant.py"
 605     _ant_script = "//build/android/ant/apk-package.xml"
 606
 607     deps = [
 608       ":${_package_resources_target_name}",
 609     ]
 610     depfile = "$target_gen_dir/$target_name.d"
 611
 612     inputs = [
 613       _resource_packaged_apk_path,
 614       _ant_script,
 615     ]
 616     if (defined(_dex_path)) {
 617       inputs += [ _dex_path ]
 618     }
 619
 620     outputs = [
 621       depfile,
 622       _packaged_apk_path,
 623     ]
 624
 625     _rebased_emma_jar = ""
 626     _rebased_resource_packaged_apk_path =
 627         rebase_path(_resource_packaged_apk_path, root_build_dir)
 628     _rebased_packaged_apk_path = rebase_path(_packaged_apk_path, root_build_dir)
 629     _rebased_native_libs_dir = rebase_path(_native_libs_dir, root_build_dir)
 630     args = [
 631       "--depfile",
 632       rebase_path(depfile, root_build_dir),
 633       "--",
 634       "-quiet",
 635       "-DANDROID_SDK_ROOT=$rebased_android_sdk_root",
 636       "-DANDROID_SDK_TOOLS=$rebased_android_sdk_build_tools",
 637       "-DRESOURCE_PACKAGED_APK_NAME=$_rebased_resource_packaged_apk_path",
 638       "-DCONFIGURATION_NAME=$_configuration_name",
 639       "-DNATIVE_LIBS_DIR=$_rebased_native_libs_dir",
 640       "-DOUT_DIR=",
 641       "-DUNSIGNED_APK_PATH=$_rebased_packaged_apk_path",
 642       "-DEMMA_INSTRUMENT=0",
 643       "-DEMMA_DEVICE_JAR=$_rebased_emma_jar",
 644       "-Dbasedir=.",
 645       "-buildfile",
 646       rebase_path(_ant_script, root_build_dir),
 647     ]
 648     if (defined(_dex_path)) {
 649       _rebased_dex_path = rebase_path(_dex_path, root_build_dir)
 650       args += [
 651         "-DDEX_FILE_PATH=$_rebased_dex_path",
 652         "-DHAS_CODE=true",
 653       ]
 654     } else {
 655       args += [ "-DHAS_CODE=false" ]
 656     }
 657   }
 658
 659   _finalize_apk_rule_name = "${target_name}__finalize"
 660   finalize_apk(_finalize_apk_rule_name) {
 661     input_apk_path = _packaged_apk_path
 662     output_apk_path = _final_apk_path
 663     keystore_path = invoker.keystore_path
 664     keystore_name = invoker.keystore_name
 665     keystore_password = invoker.keystore_password
 666     rezip_apk = _load_library_from_apk
 667   }
 668
 669   _final_deps = [ ":${_finalize_apk_rule_name}" ]
 670
 671   if (_create_density_splits) {
 672     foreach(_density, _split_densities) {
 673       _finalize_split_rule_name = "${target_name}__finalize_${_density}_split"
 674       finalize_apk(_finalize_split_rule_name) {
 675         input_apk_path = "${_resource_packaged_apk_path}-${_density}"
 676         _output_paths = process_file_template(
 677                 [ _final_apk_path ],
 678                 "{{source_dir}}/{{source_name_part}}-${_density}.apk")
 679         output_apk_path = _output_paths[0]
 680         keystore_path = invoker.keystore_path
 681         keystore_name = invoker.keystore_name
 682         keystore_password = invoker.keystore_password
 683       }
 684       _final_deps += [ ":${_finalize_split_rule_name}" ]
 685     }
 686   }
 687
 688   group(target_name) {
 689     deps = _final_deps
 690   }
 691 }
 692
 693 template("java_prebuilt_impl") {
 694   set_sources_assignment_filter([])
 695   if (defined(invoker.testonly)) {
 696     testonly = invoker.testonly
 697   }
 698   _supports_android =
 699       defined(invoker.supports_android) && invoker.supports_android
 700
 701   assert(defined(invoker.jar_path))
 702   _base_path = "${target_gen_dir}/$target_name"
 703   _jar_path = _base_path + ".jar"
 704   _build_config = _base_path + ".build_config"
 705
 706   if (_supports_android) {
 707     _dex_path = _base_path + ".dex.jar"
 708   }
 709
 710   _final_deps = []
 711   _template_name = target_name
 712
 713   _final_deps += [ ":${_template_name}__build_config" ]
 714   write_build_config("${_template_name}__build_config") {
 715     type = "java_library"
 716     supports_android = _supports_android
 717     requires_android =
 718         defined(invoker.requires_android) && invoker.requires_android
 719
 720     deps = []
 721     if (defined(invoker.deps)) {
 722       deps += invoker.deps
 723     }
 724     build_config = _build_config
 725     jar_path = _jar_path
 726     if (_supports_android) {
 727       dex_path = _dex_path
 728     }
 729   }
 730
 731   _final_deps += [ ":${_template_name}__process_jar" ]
 732   process_java_prebuilt("${_template_name}__process_jar") {
 733     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 734       proguard_preprocess = true
 735       proguard_config = invoker.proguard_config
 736     }
 737
 738     build_config = _build_config
 739     input_jar_path = invoker.jar_path
 740     output_jar_path = _jar_path
 741   }
 742
 743   if (_supports_android) {
 744     _final_deps += [ ":${_template_name}__dex" ]
 745     dex("${_template_name}__dex") {
 746       sources = [
 747         _jar_path,
 748       ]
 749       output = _dex_path
 750     }
 751   }
 752
 753   group(target_name) {
 754     deps = _final_deps
 755   }
 756 }
 757
 758 # Compiles and jars a set of java files.
 759 #
 760 # Outputs:
 761 #  $jar_path.jar
 762 #  $jar_path.jar.TOC
 763 #
 764 # Variables
 765 #   java_files: List of .java files to compile.
 766 #   java_deps: List of java dependencies. These should all have a .jar output
 767 #     at "${target_gen_dir}/${target_name}.jar.
 768 #   chromium_code: If true, enable extra warnings.
 769 #   srcjar_deps: List of srcjar dependencies. The .java files contained in the
 770 #     dependencies srcjar outputs will be compiled and added to the output jar.
 771 #   jar_path: Use this to explicitly set the output jar path. Defaults to
 772 #     "${target_gen_dir}/${target_name}.jar.
 773 template("compile_java") {
 774   set_sources_assignment_filter([])
 775   if (defined(invoker.testonly)) {
 776     testonly = invoker.testonly
 777   }
 778
 779   assert(defined(invoker.java_files))
 780   assert(defined(invoker.build_config))
 781   assert(defined(invoker.jar_path))
 782
 783   _java_files = invoker.java_files
 784   _final_jar_path = invoker.jar_path
 785   _intermediate_jar_path = "$target_gen_dir/$target_name.initial.jar"
 786
 787   _build_config = invoker.build_config
 788
 789   _jar_excluded_patterns = []
 790   if (defined(invoker.jar_excluded_patterns)) {
 791     _jar_excluded_patterns += invoker.jar_excluded_patterns
 792   }
 793
 794   _chromium_code = false
 795   if (defined(invoker.chromium_code)) {
 796     _chromium_code = invoker.chromium_code
 797   }
 798   _manifest_entries = []
 799   if (defined(invoker.manifest_entries)) {
 800     _manifest_entries = invoker.manifest_entries
 801   }
 802
 803   _srcjar_deps = []
 804   if (defined(invoker.srcjar_deps)) {
 805     _srcjar_deps += invoker.srcjar_deps
 806   }
 807
 808   _java_srcjars = []
 809   if (defined(invoker.srcjars)) {
 810     _java_srcjars = invoker.srcjars
 811   }
 812   foreach(dep, _srcjar_deps) {
 813     _dep_gen_dir = get_label_info(dep, "target_gen_dir")
 814     _dep_name = get_label_info(dep, "name")
 815     _java_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
 816   }
 817
 818   # Mark srcjar_deps as used.
 819   assert(_srcjar_deps == [] || true)
 820
 821   _system_jars = []
 822   if (defined(invoker.android) && invoker.android) {
 823     _system_jars += [ android_sdk_jar ]
 824   }
 825
 826   _rebased_build_config = rebase_path(_build_config, root_build_dir)
 827   _rebased_jar_path = rebase_path(_intermediate_jar_path, root_build_dir)
 828
 829   _template_name = target_name
 830   _final_deps = [ ":${_template_name}__javac" ]
 831   action("${_template_name}__javac") {
 832     script = "//build/android/gyp/javac.py"
 833     depfile = "$target_gen_dir/$target_name.d"
 834     deps = []
 835     outputs = [
 836       depfile,
 837       _intermediate_jar_path,
 838       _intermediate_jar_path + ".md5.stamp",
 839     ]
 840     sources = _java_files + _java_srcjars
 841     inputs = _system_jars + [ _build_config ]
 842
 843     _rebased_system_jars = rebase_path(_system_jars, root_build_dir)
 844     _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
 845     _rebased_depfile = rebase_path(depfile, root_build_dir)
 846     args = [
 847       "--depfile=$_rebased_depfile",
 848       "--classpath=$_rebased_system_jars",
 849       "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
 850       "--jar-path=$_rebased_jar_path",
 851       "--java-srcjars=$_rebased_java_srcjars",
 852       "--java-srcjars=@FileArg($_rebased_build_config:javac:srcjars)",
 853       "--jar-excluded-classes=$_jar_excluded_patterns",
 854     ]
 855     foreach(e, _manifest_entries) {
 856       args += [ "--manifest-entry=" + e ]
 857     }
 858     if (_chromium_code) {
 859       args += [ "--chromium-code=1" ]
 860     }
 861
 862     args += rebase_path(_java_files, root_build_dir)
 863   }
 864
 865   _final_deps += [ ":${_template_name}__finish" ]
 866   process_java_prebuilt("${_template_name}__finish") {
 867     build_config = _build_config
 868     input_jar_path = _intermediate_jar_path
 869     output_jar_path = _final_jar_path
 870     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
 871       proguard_preprocess = invoker.proguard_preprocess
 872       proguard_config = invoker.proguard_config
 873     }
 874   }
 875
 876   group(target_name) {
 877     deps = _final_deps
 878   }
 879 }
 880
 881 template("java_library_impl") {
 882   set_sources_assignment_filter([])
 883   if (defined(invoker.testonly)) {
 884     testonly = invoker.testonly
 885   }
 886
 887   assert(
 888       defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir) ||
 889       defined(invoker.srcjars) || defined(invoker.srcjar_deps))
 890   _base_path = "$target_gen_dir/$target_name"
 891   _jar_path = _base_path + ".jar"
 892   if (defined(invoker.jar_path)) {
 893     _jar_path = invoker.jar_path
 894   }
 895   _template_name = target_name
 896
 897   _final_deps = []
 898   _final_datadeps = []
 899   if (defined(invoker.datadeps)) {
 900     _final_datadeps = invoker.datadeps
 901   }
 902
 903   _supports_android =
 904       defined(invoker.supports_android) && invoker.supports_android
 905   _requires_android =
 906       defined(invoker.requires_android) && invoker.requires_android
 907
 908   if (_supports_android) {
 909     _dex_path = _base_path + ".dex.jar"
 910     if (defined(invoker.dex_path)) {
 911       _dex_path = invoker.dex_path
 912     }
 913   }
 914
 915   if (defined(invoker.override_build_config)) {
 916     _build_config = invoker.override_build_config
 917   } else {
 918     _build_config = _base_path + ".build_config"
 919     _final_deps += [ ":${_template_name}__build_config" ]
 920     write_build_config("${_template_name}__build_config") {
 921       type = "java_library"
 922       supports_android = _supports_android
 923       requires_android = _requires_android
 924       bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
 925                                invoker.bypass_platform_checks
 926
 927       deps = []
 928       if (defined(invoker.deps)) {
 929         deps += invoker.deps
 930       }
 931
 932       build_config = _build_config
 933       jar_path = _jar_path
 934       if (_supports_android) {
 935         dex_path = _dex_path
 936       }
 937     }
 938   }
 939
 940   _chromium_code = true
 941   if (defined(invoker.chromium_code)) {
 942     _chromium_code = invoker.chromium_code
 943   }
 944
 945   _srcjar_deps = []
 946   if (defined(invoker.srcjar_deps)) {
 947     _srcjar_deps = invoker.srcjar_deps
 948   }
 949
 950   _srcjars = []
 951   if (defined(invoker.srcjars)) {
 952     _srcjars = invoker.srcjars
 953   }
 954
 955   _java_files = []
 956   if (defined(invoker.java_files)) {
 957     _java_files = invoker.java_files
 958   } else if (defined(invoker.DEPRECATED_java_in_dir)) {
 959     _src_dir = invoker.DEPRECATED_java_in_dir + "/src"
 960     _src_dir_exists = exec_script("//build/dir_exists.py",
 961                                   [ rebase_path(_src_dir, root_build_dir) ],
 962                                   "string")
 963     assert(_src_dir_exists == "False",
 964            "In GN, java_in_dir should be the fully specified java directory " +
 965                "(i.e. including the trailing \"/src\")")
 966
 967     _java_files_build_rel = exec_script(
 968             "//build/android/gyp/find.py",
 969             [
 970               "--pattern",
 971               "*.java",
 972               rebase_path(invoker.DEPRECATED_java_in_dir, root_build_dir),
 973             ],
 974             "list lines")
 975     _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
 976   }
 977   assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
 978
 979   _final_deps += [ ":${_template_name}__compile_java" ]
 980   compile_java("${_template_name}__compile_java") {
 981     jar_path = _jar_path
 982     build_config = _build_config
 983     java_files = _java_files
 984     srcjar_deps = _srcjar_deps
 985     srcjars = _srcjars
 986     chromium_code = _chromium_code
 987     android = _requires_android
 988
 989     if (defined(invoker.jar_excluded_patterns)) {
 990       jar_excluded_patterns = invoker.jar_excluded_patterns
 991     }
 992     if (defined(invoker.proguard_preprocess)) {
 993       proguard_preprocess = invoker.proguard_preprocess
 994     }
 995     if (defined(invoker.proguard_config)) {
 996       proguard_config = invoker.proguard_config
 997     }
 998     if (defined(invoker.dist_jar_path)) {
 999       dist_jar_path = invoker.dist_jar_path
1000     }
1001     if (defined(invoker.manifest_entries)) {
1002       manifest_entries = invoker.manifest_entries
1003     }
1004   }
1005
1006   if (defined(invoker.main_class)) {
1007     _final_deps += [ ":${_template_name}__binary_script" ]
1008     action("${_template_name}__binary_script") {
1009       script = "//build/android/gyp/create_java_binary_script.py"
1010       depfile = "$target_gen_dir/$target_name.d"
1011       java_script = "$root_build_dir/bin/$_template_name"
1012       inputs = [
1013         _build_config,
1014       ]
1015       outputs = [
1016         depfile,
1017         java_script,
1018       ]
1019       _rebased_build_config = rebase_path(_build_config, root_build_dir)
1020       args = [
1021         "--depfile",
1022         rebase_path(depfile, root_build_dir),
1023         "--output",
1024         rebase_path(java_script, root_build_dir),
1025         "--classpath=@FileArg($_rebased_build_config:java:full_classpath)",
1026         "--jar-path",
1027         rebase_path(_jar_path, root_build_dir),
1028         "--main-class",
1029         invoker.main_class,
1030       ]
1031     }
1032   }
1033
1034   if (_supports_android) {
1035     if (defined(invoker.chromium_code) && invoker.chromium_code) {
1036       _android_manifest = "//build/android/AndroidManifest.xml"
1037       if (defined(invoker.android_manifest)) {
1038         _android_manifest = invoker.android_manifest
1039       }
1040
1041       _final_datadeps += [ ":${_template_name}__lint" ]
1042       android_lint("${_template_name}__lint") {
1043         android_manifest = _android_manifest
1044         jar_path = _jar_path
1045         java_files = _java_files
1046       }
1047
1048       if (run_findbugs) {
1049         _final_datadeps += [ ":${_template_name}__findbugs" ]
1050         findbugs("${_template_name}__findbugs") {
1051           build_config = _build_config
1052           jar_path = _jar_path
1053         }
1054       }
1055     }
1056
1057     _final_deps += [ ":${_template_name}__dex" ]
1058     dex("${_template_name}__dex") {
1059       sources = [
1060         _jar_path,
1061       ]
1062       output = _dex_path
1063     }
1064   }
1065
1066   group(target_name) {
1067     if (defined(invoker.visibility)) {
1068       visibility = invoker.visibility
1069     }
1070     deps = _final_deps
1071     datadeps = _final_datadeps
1072   }
1073 }
1074
1075 # Runs process_resources.py
1076 template("process_resources") {
1077   set_sources_assignment_filter([])
1078   if (defined(invoker.testonly)) {
1079     testonly = invoker.testonly
1080   }
1081
1082   zip_path = invoker.zip_path
1083   srcjar_path = invoker.srcjar_path
1084   r_text_path = invoker.r_text_path
1085   build_config = invoker.build_config
1086   resource_dirs = invoker.resource_dirs
1087   android_manifest = invoker.android_manifest
1088
1089   non_constant_id = true
1090   if (defined(invoker.generate_constant_ids) && invoker.generate_constant_ids) {
1091     non_constant_id = false
1092   }
1093
1094   action(target_name) {
1095     script = "//build/android/gyp/process_resources.py"
1096
1097     depfile = "$target_gen_dir/$target_name.d"
1098     outputs = [
1099       depfile,
1100       zip_path,
1101       srcjar_path,
1102       r_text_path,
1103     ]
1104
1105     sources_build_rel = exec_script("//build/android/gyp/find.py",
1106                                     rebase_path(resource_dirs, root_build_dir),
1107                                     "list lines")
1108     sources = rebase_path(sources_build_rel, ".", root_build_dir)
1109
1110     inputs = [
1111       build_config,
1112       android_manifest,
1113     ]
1114
1115     rebase_resource_dirs = rebase_path(resource_dirs, root_build_dir)
1116     rebase_build_config = rebase_path(build_config, root_build_dir)
1117     args = [
1118       "--depfile",
1119       rebase_path(depfile, root_build_dir),
1120       "--android-sdk",
1121       rebase_path(android_sdk, root_build_dir),
1122       "--android-sdk-tools",
1123       rebase_path(android_sdk_build_tools, root_build_dir),
1124       "--android-manifest",
1125       rebase_path(android_manifest, root_build_dir),
1126       "--resource-dirs=$rebase_resource_dirs",
1127       "--srcjar-out",
1128       rebase_path(srcjar_path, root_build_dir),
1129       "--resource-zip-out",
1130       rebase_path(zip_path, root_build_dir),
1131       "--r-text-out",
1132       rebase_path(r_text_path, root_build_dir),
1133       "--dependencies-res-zips=@FileArg($rebase_build_config:resources:dependency_zips)",
1134       "--extra-res-packages=@FileArg($rebase_build_config:resources:extra_package_names)",
1135       "--extra-r-text-files=@FileArg($rebase_build_config:resources:extra_r_text_files)",
1136     ]
1137
1138     if (non_constant_id) {
1139       args += [ "--non-constant-id" ]
1140     }
1141
1142     if (defined(invoker.custom_package)) {
1143       args += [
1144         "--custom-package",
1145         invoker.custom_package,
1146       ]
1147     }
1148
1149     if (defined(invoker.v14_skip) && invoker.v14_skip) {
1150       args += [ "--v14-skip" ]
1151     }
1152
1153     if (defined(invoker.shared_resources) && invoker.shared_resources) {
1154       args += [ "--shared-resources" ]
1155     }
1156
1157     if (defined(invoker.include_all_resources) &&
1158         invoker.include_all_resources) {
1159       args += [ "--include-all-resources" ]
1160     }
1161
1162     if (defined(invoker.all_resources_zip_path)) {
1163       all_resources_zip = invoker.all_resources_zip_path
1164       outputs += [ all_resources_zip ]
1165       args += [
1166         "--all-resources-zip-out",
1167         rebase_path(all_resources_zip, root_build_dir),
1168       ]
1169     }
1170
1171     if (defined(invoker.args)) {
1172       args += invoker.args
1173     }
1174   }
1175 }
1176
1177 template("copy_ex") {
1178   set_sources_assignment_filter([])
1179   if (defined(invoker.testonly)) {
1180     testonly = invoker.testonly
1181   }
1182
1183   action(target_name) {
1184     script = "//build/android/gyp/copy_ex.py"
1185
1186     if (defined(invoker.deps)) {
1187       deps = invoker.deps
1188     }
1189
1190     sources = []
1191     if (defined(invoker.sources)) {
1192       sources += invoker.sources
1193     }
1194
1195     inputs = []
1196     if (defined(invoker.inputs)) {
1197       inputs += invoker.inputs
1198     }
1199
1200     depfile = "$target_gen_dir/$target_name.d"
1201     outputs = [
1202       depfile,
1203     ]
1204
1205     args = [
1206       "--depfile",
1207       rebase_path(depfile, root_build_dir),
1208       "--dest",
1209       rebase_path(invoker.dest, root_build_dir),
1210     ]
1211     rebased_sources = rebase_path(sources, root_build_dir)
1212     args += [ "--files=$rebased_sources" ]
1213
1214     if (defined(invoker.clear_dir) && invoker.clear_dir) {
1215       args += [ "--clear" ]
1216     }
1217
1218     if (defined(invoker.args)) {
1219       args += invoker.args
1220     }
1221   }
1222 }
1223
1224 # Produces a single .dex.jar out of a set of Java dependencies.
1225 template("deps_dex") {
1226   set_sources_assignment_filter([])
1227   build_config = "$target_gen_dir/${target_name}.build_config"
1228   write_build_config("${target_name}__build_config") {
1229     type = "deps_dex"
1230     deps = invoker.deps
1231
1232     build_config = build_config
1233     dex_path = invoker.dex_path
1234   }
1235
1236   rebased_build_config = rebase_path(build_config, root_build_dir)
1237   dex(target_name) {
1238     inputs = [
1239       build_config,
1240     ]
1241     output = invoker.dex_path
1242     dex_arg_key = "${rebased_build_config}:final_dex:dependency_dex_files"
1243     args = [ "--inputs=@FileArg($dex_arg_key)" ]
1244     if (defined(invoker.excluded_jars)) {
1245       excluded_jars = rebase_path(invoker.excluded_jars, root_build_dir)
1246       args += [ "--excluded-paths=${excluded_jars}" ]
1247     }
1248   }
1249 }
1250
1251 # Creates an AndroidManifest.xml for an APK split.
1252 template("generate_split_manifest") {
1253   assert(defined(invoker.main_manifest))
1254   assert(defined(invoker.out_manifest))
1255   assert(defined(invoker.split_name))
1256
1257   action(target_name) {
1258     depfile = "$target_gen_dir/$target_name.d"
1259     args = [
1260       "--main-manifest",
1261       rebase_path(invoker.main_manifest, root_build_dir),
1262       "--out-manifest",
1263       rebase_path(invoker.out_manifest, root_build_dir),
1264       "--split",
1265       invoker.split_name,
1266     ]
1267     if (defined(invoker.version_code)) {
1268       args += [
1269         "--version-code",
1270         invoker.version_code,
1271       ]
1272     }
1273     if (defined(invoker.version_name)) {
1274       args += [
1275         "--version-name",
1276         invoker.version_name,
1277       ]
1278     }
1279     if (defined(invoker.has_code)) {
1280       args += [
1281         "--has-code",
1282         invoker.has_code,
1283       ]
1284     }
1285     args += [
1286       "--depfile",
1287       rebase_path(depfile, root_build_dir),
1288     ]
1289
1290     script = "//build/android/gyp/generate_split_manifest.py"
1291     outputs = [
1292       depfile,
1293       invoker.out_manifest,
1294     ]
1295     inputs = [
1296       invoker.main_manifest,
1297     ]
1298   }
1299 }