build/config/android/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("//base/android/linker/config.gni")
   6 import("//build/config/android/config.gni")
   7 import("//build/config/android/internal_rules.gni")
   8 import("//build/toolchain/toolchain.gni")
   9 import("//third_party/android_platform/config.gni")
  10 import("//tools/grit/grit_rule.gni")
  11
  12 assert(is_android)
  13
  14 # Declare a jni target
  15 #
  16 # This target generates the native jni bindings for a set of .java files.
  17 #
  18 # See base/android/jni_generator/jni_generator.py for more info about the
  19 # format of generating JNI bindings.
  20 #
  21 # Variables
  22 #   sources: list of .java files to generate jni for
  23 #   jni_package: subdirectory path for generated bindings
  24 #
  25 # Example
  26 #   generate_jni("foo_jni") {
  27 #     sources = [
  28 #       "android/java/src/org/chromium/foo/Foo.java",
  29 #       "android/java/src/org/chromium/foo/FooUtil.java",
  30 #     ]
  31 #     jni_package = "foo"
  32 #   }
  33 template("generate_jni") {
  34   set_sources_assignment_filter([])
  35   forward_variables_from(invoker, [ "testonly" ])
  36
  37   assert(defined(invoker.sources))
  38   assert(defined(invoker.jni_package))
  39   jni_package = invoker.jni_package
  40   base_output_dir = "${target_gen_dir}/${target_name}"
  41   package_output_dir = "${base_output_dir}/${jni_package}"
  42   jni_output_dir = "${package_output_dir}/jni"
  43
  44   jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h"
  45
  46   foreach_target_name = "${target_name}__jni_gen"
  47   action_foreach(foreach_target_name) {
  48     script = "//base/android/jni_generator/jni_generator.py"
  49     depfile = "$target_gen_dir/$target_name.{{source_name_part}}.d"
  50     sources = invoker.sources
  51     outputs = [
  52       depfile,
  53       "${jni_output_dir}/{{source_name_part}}_jni.h",
  54     ]
  55
  56     args = [
  57       "--depfile",
  58       rebase_path(depfile, root_build_dir),
  59       "--input_file={{source}}",
  60       "--optimize_generation=1",
  61       "--ptr_type=long",
  62       "--output_dir",
  63       rebase_path(jni_output_dir, root_build_dir),
  64       "--includes",
  65       rebase_path(jni_generator_include, jni_output_dir),
  66       "--native_exports_optional",
  67     ]
  68     if (defined(invoker.jni_generator_jarjar_file)) {
  69       args += [
  70         "--jarjar",
  71         rebase_path(jni_generator_jarjar_file, root_build_dir),
  72       ]
  73     }
  74   }
  75
  76   config("jni_includes_${target_name}") {
  77     # TODO(cjhopman): #includes should probably all be relative to
  78     # base_output_dir. Remove that from this config once the includes are
  79     # updated.
  80     include_dirs = [
  81       base_output_dir,
  82       package_output_dir,
  83     ]
  84   }
  85
  86   group(target_name) {
  87     deps = []
  88     forward_variables_from(invoker,
  89                            [
  90                              "deps",
  91                              "public_deps",
  92                              "visibility",
  93                            ])
  94     deps += [ ":$foreach_target_name" ]
  95     public_configs = [ ":jni_includes_${target_name}" ]
  96   }
  97 }
  98
  99 # Declare a jni target for a prebuilt jar
 100 #
 101 # This target generates the native jni bindings for a set of classes in a .jar.
 102 #
 103 # See base/android/jni_generator/jni_generator.py for more info about the
 104 # format of generating JNI bindings.
 105 #
 106 # Variables
 107 #   classes: list of .class files in the jar to generate jni for. These should
 108 #     include the full path to the .class file.
 109 #   jni_package: subdirectory path for generated bindings
 110 #   jar_file: the path to the .jar. If not provided, will default to the sdk's
 111 #     android.jar
 112 #
 113 #   deps, public_deps: As normal
 114 #
 115 # Example
 116 #   generate_jar_jni("foo_jni") {
 117 #     classes = [
 118 #       "android/view/Foo.class",
 119 #     ]
 120 #     jni_package = "foo"
 121 #   }
 122 template("generate_jar_jni") {
 123   set_sources_assignment_filter([])
 124   forward_variables_from(invoker, [ "testonly" ])
 125
 126   assert(defined(invoker.classes))
 127   assert(defined(invoker.jni_package))
 128
 129   if (defined(invoker.jar_file)) {
 130     jar_file = invoker.jar_file
 131   } else {
 132     jar_file = android_sdk_jar
 133   }
 134
 135   jni_package = invoker.jni_package
 136   base_output_dir = "${root_gen_dir}/${target_name}/${jni_package}"
 137   jni_output_dir = "${base_output_dir}/jni"
 138
 139   jni_generator_include = "//base/android/jni_generator/jni_generator_helper.h"
 140
 141   # TODO(cjhopman): make jni_generator.py support generating jni for multiple
 142   # .class files from a .jar.
 143   jni_actions = []
 144   foreach(class, invoker.classes) {
 145     _classname_list = []
 146     _classname_list = process_file_template([ class ], "{{source_name_part}}")
 147     classname = _classname_list[0]
 148     jni_target_name = "${target_name}__jni_${classname}"
 149     jni_actions += [ ":$jni_target_name" ]
 150     action(jni_target_name) {
 151       # The sources aren't compiled so don't check their dependencies.
 152       check_includes = false
 153       depfile = "$target_gen_dir/$target_name.d"
 154       script = "//base/android/jni_generator/jni_generator.py"
 155       sources = [
 156         jar_file,
 157       ]
 158       outputs = [
 159         depfile,
 160         "${jni_output_dir}/${classname}_jni.h",
 161       ]
 162
 163       args = [
 164         "--depfile",
 165         rebase_path(depfile, root_build_dir),
 166         "--jar_file",
 167         rebase_path(jar_file, root_build_dir),
 168         "--input_file",
 169         class,
 170         "--optimize_generation=1",
 171         "--ptr_type=long",
 172         "--output_dir",
 173         rebase_path(jni_output_dir, root_build_dir),
 174         "--includes",
 175         rebase_path(jni_generator_include, jni_output_dir),
 176         "--native_exports_optional",
 177       ]
 178     }
 179   }
 180
 181   config("jni_includes_${target_name}") {
 182     include_dirs = [ base_output_dir ]
 183   }
 184
 185   group(target_name) {
 186     deps = []
 187     forward_variables_from(invoker,
 188                            [
 189                              "deps",
 190                              "public_deps",
 191                              "visibility",
 192                            ])
 193     deps += jni_actions
 194     public_configs = [ ":jni_includes_${target_name}" ]
 195   }
 196 }
 197
 198 # Declare a target for c-preprocessor-generated java files
 199 #
 200 # NOTE: For generating Java conterparts to enums prefer using the java_cpp_enum
 201 #       rule instead.
 202 #
 203 # This target generates java files using the host C pre-processor. Each file in
 204 # sources will be compiled using the C pre-processor. If include_path is
 205 # specified, it will be passed (with --I) to the pre-processor.
 206 #
 207 # This target will create a single .srcjar. Adding this target to an
 208 # android_library target's srcjar_deps will make the generated java files be
 209 # included in that library's final outputs.
 210 #
 211 # Variables
 212 #   sources: list of files to be processed by the C pre-processor. For each
 213 #     file in sources, there will be one .java file in the final .srcjar. For a
 214 #     file named FooBar.template, a java file will be created with name
 215 #     FooBar.java.
 216 #   inputs: additional compile-time dependencies. Any files
 217 #     `#include`-ed in the templates should be listed here.
 218 #   package_name: this will be the subdirectory for each .java file in the
 219 #     .srcjar.
 220 #
 221 # Example
 222 #   java_cpp_template("foo_generated_enum") {
 223 #     sources = [
 224 #       "android/java/templates/Foo.template",
 225 #     ]
 226 #     inputs = [
 227 #       "android/java/templates/native_foo_header.h",
 228 #     ]
 229 #
 230 #     package_name = "org/chromium/base/library_loader"
 231 #     include_path = "android/java/templates"
 232 #   }
 233 template("java_cpp_template") {
 234   set_sources_assignment_filter([])
 235   forward_variables_from(invoker, [ "testonly" ])
 236
 237   assert(defined(invoker.sources))
 238   package_name = invoker.package_name + ""
 239
 240   if (defined(invoker.include_path)) {
 241     include_path = invoker.include_path + ""
 242   } else {
 243     include_path = "//"
 244   }
 245
 246   apply_gcc_target_name = "${target_name}__apply_gcc"
 247   zip_srcjar_target_name = "${target_name}__zip_srcjar"
 248   final_target_name = target_name
 249
 250   action_foreach(apply_gcc_target_name) {
 251     forward_variables_from(invoker,
 252                            [
 253                              "deps",
 254                              "public_deps",
 255                              "data_deps",
 256                            ])
 257     visibility = [ ":$zip_srcjar_target_name" ]
 258     script = "//build/android/gyp/gcc_preprocess.py"
 259     if (defined(invoker.inputs)) {
 260       inputs = invoker.inputs + []
 261     }
 262     depfile = "${target_gen_dir}/${target_name}_{{source_name_part}}.d"
 263
 264     sources = invoker.sources
 265
 266     gen_dir =
 267         "${target_gen_dir}/${target_name}/java_cpp_template/${package_name}"
 268     gcc_template_output_pattern = "${gen_dir}/{{source_name_part}}.java"
 269
 270     outputs = [
 271       depfile,
 272       gcc_template_output_pattern,
 273     ]
 274
 275     args = [
 276       "--depfile",
 277       rebase_path(depfile, root_build_dir),
 278       "--include-path",
 279       rebase_path(include_path, root_build_dir),
 280       "--output",
 281       rebase_path(gen_dir, root_build_dir) + "/{{source_name_part}}.java",
 282       "--template={{source}}",
 283     ]
 284
 285     if (defined(invoker.defines)) {
 286       foreach(def, invoker.defines) {
 287         args += [
 288           "--defines",
 289           def,
 290         ]
 291       }
 292     }
 293   }
 294
 295   apply_gcc_outputs = get_target_outputs(":$apply_gcc_target_name")
 296   base_gen_dir = get_label_info(":$apply_gcc_target_name", "target_gen_dir")
 297
 298   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
 299   zip(zip_srcjar_target_name) {
 300     visibility = [ ":$final_target_name" ]
 301     inputs = apply_gcc_outputs
 302     output = srcjar_path
 303     base_dir = base_gen_dir
 304     deps = [
 305       ":$apply_gcc_target_name",
 306     ]
 307   }
 308
 309   group(final_target_name) {
 310     forward_variables_from(invoker, [ "visibility" ])
 311     deps = [
 312       ":$zip_srcjar_target_name",
 313     ]
 314   }
 315 }
 316
 317 # Declare a target for generating Java classes from C++ enums.
 318 #
 319 # This target generates Java files from C++ enums using a script.
 320 #
 321 # This target will create a single .srcjar. Adding this target to an
 322 # android_library target's srcjar_deps will make the generated java files be
 323 # included in that library's final outputs.
 324 #
 325 # Variables
 326 #   sources: list of files to be processed by the script. For each annotated
 327 #     enum contained in the sources files the script will generate a .java
 328 #     file with the same name as the name of the enum.
 329 #
 330 #   outputs: list of outputs, relative to the output_dir. These paths are
 331 #     verified at build time by the script. To get the list programatically run:
 332 #       python build/android/gyp/java_cpp_enum.py \
 333 #         --print_output_only . path/to/header/file.h
 334 #
 335 # Example
 336 #   java_cpp_enum("foo_generated_enum") {
 337 #     sources = [
 338 #       "src/native_foo_header.h",
 339 #     ]
 340 #     outputs = [
 341 #       "org/chromium/FooEnum.java",
 342 #     ]
 343 #   }
 344 template("java_cpp_enum") {
 345   set_sources_assignment_filter([])
 346   forward_variables_from(invoker, [ "testonly" ])
 347
 348   assert(defined(invoker.sources))
 349   assert(defined(invoker.outputs))
 350
 351   generate_enum_target_name = "${target_name}__generate_enum"
 352   zip_srcjar_target_name = "${target_name}__zip_srcjar"
 353   final_target_name = target_name
 354
 355   action(generate_enum_target_name) {
 356     visibility = [ ":$zip_srcjar_target_name" ]
 357
 358     # The sources aren't compiled so don't check their dependencies.
 359     check_includes = false
 360
 361     sources = invoker.sources
 362     script = "//build/android/gyp/java_cpp_enum.py"
 363     gen_dir = "${target_gen_dir}/${target_name}/enums"
 364     outputs =
 365         get_path_info(rebase_path(invoker.outputs, ".", gen_dir), "abspath")
 366
 367     args = []
 368     foreach(output, rebase_path(outputs, root_build_dir)) {
 369       args += [
 370         "--assert_file",
 371         output,
 372       ]
 373     }
 374     args += [ rebase_path(gen_dir, root_build_dir) ]
 375     args += rebase_path(invoker.sources, root_build_dir)
 376   }
 377
 378   generate_enum_outputs = get_target_outputs(":$generate_enum_target_name")
 379   base_gen_dir = get_label_info(":$generate_enum_target_name", "target_gen_dir")
 380
 381   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
 382   zip(zip_srcjar_target_name) {
 383     visibility = [ ":$final_target_name" ]
 384     inputs = generate_enum_outputs
 385     output = srcjar_path
 386     base_dir = base_gen_dir
 387     deps = [
 388       ":$generate_enum_target_name",
 389     ]
 390   }
 391
 392   group(final_target_name) {
 393     forward_variables_from(invoker, [ "visibility" ])
 394     deps = [
 395       ":$zip_srcjar_target_name",
 396     ]
 397   }
 398 }
 399
 400 # Declare a target for processing a Jinja template.
 401 #
 402 # Variables
 403 #   input: The template file to be processed.
 404 #   output: Where to save the result.
 405 #   variables: (Optional) A list of variables to make available to the template
 406 #     processing environment, e.g. ["name=foo", "color=red"].
 407 #
 408 # Example
 409 #   jinja_template("chrome_public_manifest") {
 410 #     input = "java/AndroidManifest.xml"
 411 #     output = "$target_gen_dir/AndroidManifest.xml"
 412 #   }
 413 template("jinja_template") {
 414   set_sources_assignment_filter([])
 415   forward_variables_from(invoker, [ "testonly" ])
 416
 417   assert(defined(invoker.input))
 418   assert(defined(invoker.output))
 419
 420   action(target_name) {
 421     forward_variables_from(invoker, [ "visibility" ])
 422
 423     sources = [
 424       invoker.input,
 425     ]
 426     script = "//build/android/gyp/jinja_template.py"
 427     depfile = "$target_gen_dir/$target_name.d"
 428
 429     outputs = [
 430       depfile,
 431       invoker.output,
 432     ]
 433
 434     args = [
 435       "--inputs",
 436       rebase_path(invoker.input, root_build_dir),
 437       "--output",
 438       rebase_path(invoker.output, root_build_dir),
 439       "--depfile",
 440       rebase_path(depfile, root_build_dir),
 441     ]
 442     if (defined(invoker.variables)) {
 443       variables = invoker.variables
 444       args += [ "--variables=${variables}" ]
 445     }
 446   }
 447 }
 448
 449 # Declare a target for processing Android resources as Jinja templates.
 450 #
 451 # This takes an Android resource directory where each resource is a Jinja
 452 # template, processes each template, then packages the results in a zip file
 453 # which can be consumed by an android resources, library, or apk target.
 454 #
 455 # If this target is included in the deps of an android resources/library/apk,
 456 # the resources will be included with that target.
 457 #
 458 # Variables
 459 #   resources: The list of resources files to process.
 460 #   res_dir: The resource directory containing the resources.
 461 #   variables: (Optional) A list of variables to make available to the template
 462 #     processing environment, e.g. ["name=foo", "color=red"].
 463 #
 464 # Example
 465 #   jinja_template_resources("chrome_public_template_resources") {
 466 #     res_dir = "res_template"
 467 #     resources = ["res_template/xml/syncable.xml"]
 468 #     variables = ["color=red"]
 469 #   }
 470 template("jinja_template_resources") {
 471   set_sources_assignment_filter([])
 472   forward_variables_from(invoker, [ "testonly" ])
 473
 474   assert(defined(invoker.resources))
 475   assert(defined(invoker.res_dir))
 476
 477   _base_path = "$target_gen_dir/$target_name"
 478   _resources_zip = _base_path + ".resources.zip"
 479   _build_config = _base_path + ".build_config"
 480
 481   write_build_config("${target_name}__build_config") {
 482     build_config = _build_config
 483     resources_zip = _resources_zip
 484     type = "android_resources"
 485   }
 486
 487   action("${target_name}__template") {
 488     sources = invoker.resources
 489     script = "//build/android/gyp/jinja_template.py"
 490     depfile = "$target_gen_dir/$target_name.d"
 491
 492     outputs = [
 493       depfile,
 494       _resources_zip,
 495     ]
 496
 497     rebased_resources = rebase_path(invoker.resources, root_build_dir)
 498     args = [
 499       "--inputs=${rebased_resources}",
 500       "--inputs-base-dir",
 501       rebase_path(invoker.res_dir, root_build_dir),
 502       "--outputs-zip",
 503       rebase_path(_resources_zip, root_build_dir),
 504       "--depfile",
 505       rebase_path(depfile, root_build_dir),
 506     ]
 507     if (defined(invoker.variables)) {
 508       variables = invoker.variables
 509       args += [ "--variables=${variables}" ]
 510     }
 511   }
 512
 513   group(target_name) {
 514     deps = [
 515       ":${target_name}__build_config",
 516       ":${target_name}__template",
 517     ]
 518   }
 519 }
 520
 521 # Creates a resources.zip with locale.pak files placed into appropriate
 522 # resource configs (e.g. en-GB.pak -> res/raw-en/en_gb.pak). Also generates
 523 # a locale_paks TypedArray so that resource files can be enumerated at runtime.
 524 #
 525 # If this target is included in the deps of an android resources/library/apk,
 526 # the resources will be included with that target.
 527 #
 528 # Variables:
 529 #   sources: List of .pak files. Names must be of the form "en.pak" or
 530 #       "en-US.pak".
 531 #   deps: (optional) List of dependencies that might be needed to generate
 532 #       the .pak files.
 533 #
 534 # Example
 535 #   locale_pak_resources("locale_paks") {
 536 #     sources = [ "path/en-US.pak", "path/fr.pak", ... ]
 537 #   }
 538 template("locale_pak_resources") {
 539   set_sources_assignment_filter([])
 540   assert(defined(invoker.sources))
 541
 542   _base_path = "$target_gen_dir/$target_name"
 543   _resources_zip = _base_path + ".resources.zip"
 544   _build_config = _base_path + ".build_config"
 545
 546   write_build_config("${target_name}__build_config") {
 547     build_config = _build_config
 548     resources_zip = _resources_zip
 549     type = "android_resources"
 550   }
 551
 552   action("${target_name}__create_resources_zip") {
 553     forward_variables_from(invoker,
 554                            [
 555                              "deps",
 556                              "sources",
 557                            ])
 558     script = "//build/android/gyp/locale_pak_resources.py"
 559     depfile = "$target_gen_dir/$target_name.d"
 560
 561     outputs = [
 562       depfile,
 563       _resources_zip,
 564     ]
 565
 566     _rebased_sources = rebase_path(sources, root_build_dir)
 567     args = [
 568       "--locale-paks=${_rebased_sources}",
 569       "--resources-zip",
 570       rebase_path(_resources_zip, root_build_dir),
 571       "--depfile",
 572       rebase_path(depfile, root_build_dir),
 573     ]
 574   }
 575
 576   group(target_name) {
 577     deps = [
 578       ":${target_name}__build_config",
 579       ":${target_name}__create_resources_zip",
 580     ]
 581   }
 582 }
 583
 584 # Declare an Android resources target
 585 #
 586 # This creates a resources zip file that will be used when building an Android
 587 # library or apk and included into a final apk.
 588 #
 589 # To include these resources in a library/apk, this target should be listed in
 590 # the library's deps. A library/apk will also include any resources used by its
 591 # own dependencies.
 592 #
 593 # Variables
 594 #   deps: Specifies the dependencies of this target. Any Android resources
 595 #     listed in deps will be included by libraries/apks that depend on this
 596 #     target.
 597 #   resource_dirs: List of directories containing resources for this target.
 598 #   android_manifest: AndroidManifest.xml for this target. Defaults to
 599 #     //build/android/AndroidManifest.xml.
 600 #   custom_package: java package for generated .java files.
 601 #   v14_skip: If true, don't run v14 resource generator on this. Defaults to
 602 #     false. (see build/android/gyp/generate_v14_compatible_resources.py)
 603 #
 604 #   shared_resources: If true make a resource package that can be loaded by a
 605 #     different application at runtime to access the package's resources.
 606 #
 607
 608 # Example
 609 #   android_resources("foo_resources") {
 610 #     deps = [":foo_strings_grd"]
 611 #     resource_dirs = ["res"]
 612 #     custom_package = "org.chromium.foo"
 613 #   }
 614 template("android_resources") {
 615   set_sources_assignment_filter([])
 616   forward_variables_from(invoker, [ "testonly" ])
 617
 618   assert(defined(invoker.resource_dirs))
 619   assert(defined(invoker.android_manifest) || defined(invoker.custom_package))
 620
 621   base_path = "$target_gen_dir/$target_name"
 622   zip_path = base_path + ".resources.zip"
 623   srcjar_path = base_path + ".srcjar"
 624   r_text_path = base_path + "_R.txt"
 625   build_config = base_path + ".build_config"
 626
 627   build_config_target_name = "${target_name}__build_config"
 628   process_resources_target_name = "${target_name}__process_resources"
 629   final_target_name = target_name
 630
 631   write_build_config(build_config_target_name) {
 632     forward_variables_from(invoker,
 633                            [
 634                              "android_manifest",
 635                              "custom_package",
 636                              "deps",
 637                            ])
 638     visibility = [ ":$process_resources_target_name" ]
 639
 640     type = "android_resources"
 641     resources_zip = zip_path
 642     srcjar = srcjar_path
 643     r_text = r_text_path
 644   }
 645
 646   process_resources(process_resources_target_name) {
 647     visibility = [ ":$final_target_name" ]
 648     deps = []
 649     forward_variables_from(invoker,
 650                            [
 651                              "android_manifest",
 652                              "custom_package",
 653                              "deps",
 654                              "resource_dirs",
 655                              "shared_resources",
 656                              "v14_skip",
 657                            ])
 658     deps += [ ":$build_config_target_name" ]
 659     if (!defined(android_manifest)) {
 660       android_manifest = "//build/android/AndroidManifest.xml"
 661     }
 662   }
 663
 664   group(final_target_name) {
 665     forward_variables_from(invoker, [ "visibility" ])
 666     deps = [
 667       ":${target_name}__process_resources",
 668     ]
 669   }
 670 }
 671
 672 # Declare a target that generates localized strings.xml from a .grd file.
 673 #
 674 # If this target is included in the deps of an android resources/library/apk,
 675 # the strings.xml will be included with that target.
 676 #
 677 # Variables
 678 #   deps: Specifies the dependencies of this target.
 679 #   grd_file: Path to the .grd file to generate strings.xml from.
 680 #   outputs: Expected grit outputs (see grit rule).
 681 #
 682 # Example
 683 #  java_strings_grd("foo_strings_grd") {
 684 #    grd_file = "foo_strings.grd"
 685 #  }
 686 template("java_strings_grd") {
 687   set_sources_assignment_filter([])
 688   forward_variables_from(invoker, [ "testonly" ])
 689
 690   base_path = "$target_gen_dir/$target_name"
 691   resources_zip = base_path + ".resources.zip"
 692   build_config = base_path + ".build_config"
 693
 694   write_build_config("${target_name}__build_config") {
 695     forward_variables_from(invoker, [ "deps" ])
 696     type = "android_resources"
 697   }
 698
 699   # Put grit files into this subdirectory of target_gen_dir.
 700   extra_output_path = target_name + "_grit_output"
 701
 702   grit_target_name = "${target_name}__grit"
 703   grit_output_dir = "$target_gen_dir/$extra_output_path"
 704   grit(grit_target_name) {
 705     grit_flags = [
 706       "-E",
 707       "ANDROID_JAVA_TAGGED_ONLY=false",
 708     ]
 709     output_dir = grit_output_dir
 710     resource_ids = ""
 711     source = invoker.grd_file
 712     outputs = invoker.outputs
 713   }
 714
 715   # This needs to get outputs from grit's internal target, not the final
 716   # source_set.
 717   generate_strings_outputs = get_target_outputs(":${grit_target_name}_grit")
 718
 719   zip("${target_name}__zip") {
 720     base_dir = grit_output_dir
 721     inputs = generate_strings_outputs
 722     output = resources_zip
 723     deps = [
 724       ":$grit_target_name",
 725     ]
 726   }
 727
 728   group(target_name) {
 729     deps = [
 730       ":${target_name}__build_config",
 731       ":${target_name}__zip",
 732     ]
 733   }
 734 }
 735
 736 # Declare a target that packages strings.xml generated from a grd file.
 737 #
 738 # If this target is included in the deps of an android resources/library/apk,
 739 # the strings.xml will be included with that target.
 740 #
 741 # Variables
 742 #  grit_output_dir: directory containing grit-generated files.
 743 #  generated_files: list of android resource files to package.
 744 #
 745 # Example
 746 #  java_strings_grd_prebuilt("foo_strings_grd") {
 747 #    grit_output_dir = "$root_gen_dir/foo/grit"
 748 #    generated_files = [
 749 #      "values/strings.xml"
 750 #    ]
 751 #  }
 752 template("java_strings_grd_prebuilt") {
 753   set_sources_assignment_filter([])
 754   forward_variables_from(invoker, [ "testonly" ])
 755
 756   base_path = "$target_gen_dir/$target_name"
 757   resources_zip = base_path + ".resources.zip"
 758   build_config = base_path + ".build_config"
 759
 760   build_config_target_name = "${target_name}__build_config"
 761   zip_target_name = "${target_name}__zip"
 762   final_target_name = target_name
 763
 764   write_build_config(build_config_target_name) {
 765     visibility = [ ":$zip_target_name" ]
 766     type = "android_resources"
 767   }
 768
 769   zip(zip_target_name) {
 770     visibility = [ ":$final_target_name" ]
 771
 772     base_dir = invoker.grit_output_dir
 773     inputs = rebase_path(invoker.generated_files, ".", base_dir)
 774     output = resources_zip
 775     deps = [
 776       ":$build_config_target_name",
 777     ]
 778     if (defined(invoker.deps)) {
 779       deps += invoker.deps
 780     }
 781   }
 782
 783   group(final_target_name) {
 784     forward_variables_from(invoker, [ "visibility" ])
 785     deps = [
 786       ":$zip_target_name",
 787     ]
 788   }
 789 }
 790
 791 # Declare a Java executable target
 792 #
 793 # This target creates an executable from java code and libraries. The executable
 794 # will be in the output folder's /bin/ directory.
 795 #
 796 # Variables
 797 #   deps: Specifies the dependencies of this target. Java targets in this list
 798 #     will be included in the executable (and the javac classpath).
 799 #   java_files: List of .java files included in this library.
 800 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 801 #     will be added to java_files and be included in this library.
 802 #   srcjars: List of srcjars to be included in this library, together with the
 803 #     ones obtained from srcjar_deps.
 804 #   bypass_platform_checks: Disables checks about cross-platform (Java/Android)
 805 #     dependencies for this target. This will allow depending on an
 806 #     android_library target, for example.
 807 #   chromium_code: If true, extra analysis warning/errors will be enabled.
 808 #   enable_errorprone: If true, enables the errorprone compiler.
 809 #   main_class: When specified, a wrapper script is created within
 810 #     $target_out_dir/bin to launch the binary with the given class as the
 811 #     entrypoint.
 812 #   wrapper_script_args: List of additional arguments for the wrapper script.
 813 #
 814 #   data_deps, testonly
 815 #
 816 # Example
 817 #   java_binary("foo") {
 818 #     java_files = [ "org/chromium/foo/FooMain.java" ]
 819 #     deps = [ ":bar_java" ]
 820 #     main_class = "org.chromium.foo.FooMain"
 821 #   }
 822 template("java_binary") {
 823   set_sources_assignment_filter([])
 824
 825   # TODO(cjhopman): This should not act like a java_library for dependents (i.e.
 826   # dependents shouldn't get the jar in their classpath, etc.).
 827   java_library_impl(target_name) {
 828     forward_variables_from(invoker, "*")
 829     supports_android = false
 830     main_class = invoker.main_class
 831   }
 832 }
 833
 834 # Declare a Junit executable target
 835 #
 836 # This target creates an executable from java code for running as a junit test
 837 # suite. The executable will be in the output folder's /bin/ directory.
 838 #
 839 # Variables
 840 #   deps: Specifies the dependencies of this target. Java targets in this list
 841 #     will be included in the executable (and the javac classpath).
 842 #
 843 #   java_files: List of .java files included in this library.
 844 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 845 #     will be added to java_files and be included in this library.
 846 #   srcjars: List of srcjars to be included in this library, together with the
 847 #     ones obtained from srcjar_deps.
 848 #
 849 #   chromium_code: If true, extra analysis warning/errors will be enabled.
 850 #
 851 # Example
 852 #   junit_binary("foo") {
 853 #     java_files = [ "org/chromium/foo/FooTest.java" ]
 854 #     deps = [ ":bar_java" ]
 855 #   }
 856 template("junit_binary") {
 857   set_sources_assignment_filter([])
 858
 859   java_binary(target_name) {
 860     deps = []
 861     forward_variables_from(invoker, "*")
 862     bypass_platform_checks = true
 863     main_class = "org.chromium.testing.local.JunitTestMain"
 864     wrapper_script_args = [
 865       "-test-jars",
 866       "$target_name.jar",
 867     ]
 868     testonly = true
 869
 870     deps += [
 871       "//testing/android/junit:junit_test_support",
 872       "//third_party/junit",
 873       "//third_party/mockito:mockito_java",
 874       "//third_party/robolectric:robolectric_java",
 875       "//third_party/robolectric:android-all-4.3_r2-robolectric-0",
 876     ]
 877   }
 878 }
 879
 880 # Declare a java library target
 881 #
 882 # Variables
 883 #   deps: Specifies the dependencies of this target. Java targets in this list
 884 #     will be added to the javac classpath.
 885 #
 886 #   java_files: List of .java files included in this library.
 887 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 888 #     will be added to java_files and be included in this library.
 889 #   srcjars: List of srcjars to be included in this library, together with the
 890 #     ones obtained from srcjar_deps.
 891 #   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
 892 #     this directory will be included in the library. This is only supported to
 893 #     ease the gyp->gn conversion and will be removed in the future.
 894 #
 895 #   chromium_code: If true, extra analysis warning/errors will be enabled.
 896 #   enable_errorprone: If true, enables the errorprone compiler.
 897 #
 898 #   jar_excluded_patterns: List of patterns of .class files to exclude from the
 899 #     final jar.
 900 #
 901 #   proguard_preprocess: If true, proguard preprocessing will be run. This can
 902 #     be used to remove unwanted parts of the library.
 903 #   proguard_config: Path to the proguard config for preprocessing.
 904 #
 905 #   supports_android: If true, Android targets (android_library, android_apk)
 906 #     may depend on this target. Note: if true, this target must only use the
 907 #     subset of Java available on Android.
 908 #   bypass_platform_checks: Disables checks about cross-platform (Java/Android)
 909 #     dependencies for this target. This will allow depending on an
 910 #     android_library target, for example.
 911 #
 912 #   data_deps, testonly
 913 #
 914 # Example
 915 #   java_library("foo_java") {
 916 #     java_files = [
 917 #       "org/chromium/foo/Foo.java",
 918 #       "org/chromium/foo/FooInterface.java",
 919 #       "org/chromium/foo/FooService.java",
 920 #     ]
 921 #     deps = [
 922 #       ":bar_java"
 923 #     ]
 924 #     srcjar_deps = [
 925 #       ":foo_generated_enum"
 926 #     ]
 927 #     jar_excluded_patterns = [
 928 #       "*/FooService.class", "*/FooService##*.class"
 929 #     ]
 930 #   }
 931 template("java_library") {
 932   set_sources_assignment_filter([])
 933   java_library_impl(target_name) {
 934     forward_variables_from(invoker, "*")
 935   }
 936 }
 937
 938 # Declare a java library target for a prebuilt jar
 939 #
 940 # Variables
 941 #   deps: Specifies the dependencies of this target. Java targets in this list
 942 #     will be added to the javac classpath.
 943 #   jar_path: Path to the prebuilt jar.
 944 #   jar_dep: Target that builds jar_path (optional).
 945 #   proguard_preprocess: If true, proguard preprocessing will be run. This can
 946 #     be used to remove unwanted parts of the library.
 947 #   proguard_config: Path to the proguard config for preprocessing.
 948 #   supports_android: If true, Android targets (android_library, android_apk)
 949 #     may depend on this target. Note: if true, this target must only use the
 950 #     subset of Java available on Android.
 951 #
 952 # Example
 953 #   java_prebuilt("foo_java") {
 954 #     jar_path = "foo.jar"
 955 #     deps = [
 956 #       ":foo_resources",
 957 #       ":bar_java"
 958 #     ]
 959 #   }
 960 template("java_prebuilt") {
 961   set_sources_assignment_filter([])
 962   java_prebuilt_impl(target_name) {
 963     forward_variables_from(invoker, "*")
 964   }
 965 }
 966
 967 # Declare an Android library target
 968 #
 969 # This target creates an Android library containing java code and Android
 970 # resources.
 971 #
 972 # Variables
 973 #   deps: Specifies the dependencies of this target. Java targets in this list
 974 #     will be added to the javac classpath. Android resources in dependencies
 975 #     will be used when building this library.
 976 #
 977 #   java_files: List of .java files included in this library.
 978 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 979 #     will be added to java_files and be included in this library.
 980 #   srcjars: List of srcjars to be included in this library, together with the
 981 #     ones obtained from srcjar_deps.
 982 #   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
 983 #     this directory will be included in the library. This is only supported to
 984 #     ease the gyp->gn conversion and will be removed in the future.
 985 #
 986 #   chromium_code: If true, extra analysis warning/errors will be enabled.
 987 #   enable_errorprone: If true, enables the errorprone compiler.
 988 #
 989 #   jar_excluded_patterns: List of patterns of .class files to exclude from the
 990 #     final jar.
 991 #
 992 #   proguard_preprocess: If true, proguard preprocessing will be run. This can
 993 #     be used to remove unwanted parts of the library.
 994 #   proguard_config: Path to the proguard config for preprocessing.
 995 #
 996 #   dex_path: If set, the resulting .dex.jar file will be placed under this
 997 #     path.
 998 #
 999 #
1000 # Example
1001 #   android_library("foo_java") {
1002 #     java_files = [
1003 #       "android/org/chromium/foo/Foo.java",
1004 #       "android/org/chromium/foo/FooInterface.java",
1005 #       "android/org/chromium/foo/FooService.java",
1006 #     ]
1007 #     deps = [
1008 #       ":bar_java"
1009 #     ]
1010 #     srcjar_deps = [
1011 #       ":foo_generated_enum"
1012 #     ]
1013 #     jar_excluded_patterns = [
1014 #       "*/FooService.class", "*/FooService##*.class"
1015 #     ]
1016 #   }
1017 template("android_library") {
1018   set_sources_assignment_filter([])
1019   assert(!defined(invoker.jar_path),
1020          "android_library does not support a custom jar path")
1021   java_library_impl(target_name) {
1022     forward_variables_from(invoker, "*")
1023
1024     supports_android = true
1025     requires_android = true
1026
1027     if (!defined(jar_excluded_patterns)) {
1028       jar_excluded_patterns = []
1029     }
1030     jar_excluded_patterns += [
1031       "*/R.class",
1032       "*/R##*.class",
1033       "*/Manifest.class",
1034       "*/Manifest##*.class",
1035     ]
1036   }
1037 }
1038
1039 # Declare a target that packages a set of Java dependencies into a standalone
1040 # .dex.jar.
1041 #
1042 # Variables
1043 #   deps: specifies the dependencies of this target. Android libraries in deps
1044 #     will be packaged into the resulting .dex.jar file.
1045 #   dex_path: location at which the output file will be put
1046 template("android_standalone_library") {
1047   set_sources_assignment_filter([])
1048   deps_dex(target_name) {
1049     forward_variables_from(invoker,
1050                            [
1051                              "deps",
1052                              "dex_path",
1053                              "excluded_jars",
1054                            ])
1055   }
1056 }
1057
1058 # Declare an Android library target for a prebuilt jar
1059 #
1060 # This target creates an Android library containing java code and Android
1061 # resources.
1062 #
1063 # Variables
1064 #   deps: Specifies the dependencies of this target. Java targets in this list
1065 #     will be added to the javac classpath. Android resources in dependencies
1066 #     will be used when building this library.
1067 #   jar_path: Path to the prebuilt jar.
1068 #   proguard_preprocess: If true, proguard preprocessing will be run. This can
1069 #     be used to remove unwanted parts of the library.
1070 #   proguard_config: Path to the proguard config for preprocessing.
1071 #
1072 # Example
1073 #   android_java_prebuilt("foo_java") {
1074 #     jar_path = "foo.jar"
1075 #     deps = [
1076 #       ":foo_resources",
1077 #       ":bar_java"
1078 #     ]
1079 #   }
1080 template("android_java_prebuilt") {
1081   set_sources_assignment_filter([])
1082   java_prebuilt_impl(target_name) {
1083     forward_variables_from(invoker, "*")
1084     supports_android = true
1085     requires_android = true
1086   }
1087 }
1088
1089 # Declare an Android apk target
1090 #
1091 # This target creates an Android APK containing java code, resources, assets,
1092 # and (possibly) native libraries.
1093 #
1094 # Variables
1095 #   android_manifest: Path to AndroidManifest.xml.
1096 #   android_manifest_dep: Target that generates AndroidManifest (if applicable)
1097 #   data_deps: List of dependencies needed at runtime. These will be built but
1098 #     won't change the generated .apk in any way (in fact they may be built
1099 #     after the .apk is).
1100 #   deps: List of dependencies. All Android java resources and libraries in the
1101 #     "transitive closure" of these dependencies will be included in the apk.
1102 #     Note: this "transitive closure" actually only includes such targets if
1103 #     they are depended on through android_library or android_resources targets
1104 #     (and so not through builtin targets like 'action', 'group', etc).
1105 #   java_files: List of .java files to include in the apk.
1106 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
1107 #      will be added to java_files and be included in this apk.
1108 #   apk_name: Name for final apk.
1109 #   final_apk_path: Path to final built apk. Default is
1110 #     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
1111 #   native_libs: List paths of native libraries to include in this apk. If these
1112 #     libraries depend on other shared_library targets, those dependencies will
1113 #     also be included in the apk.
1114 #   apk_under_test: For an instrumentation test apk, this is the target of the
1115 #     tested apk.
1116 #   include_all_resources - If true include all resource IDs in all generated
1117 #     R.java files.
1118 #   testonly: Marks this target as "test-only".
1119 #
1120 #   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
1121 #     this directory will be included in the library. This is only supported to
1122 #     ease the gyp->gn conversion and will be removed in the future.
1123 #
1124 # Example
1125 #   android_apk("foo_apk") {
1126 #     android_manifest = "AndroidManifest.xml"
1127 #     java_files = [
1128 #       "android/org/chromium/foo/FooApplication.java",
1129 #       "android/org/chromium/foo/FooActivity.java",
1130 #     ]
1131 #     deps = [
1132 #       ":foo_support_java"
1133 #       ":foo_resources"
1134 #     ]
1135 #     srcjar_deps = [
1136 #       ":foo_generated_enum"
1137 #     ]
1138 #     native_libs = [
1139 #       native_lib_path
1140 #     ]
1141 #   }
1142 template("android_apk") {
1143   set_sources_assignment_filter([])
1144   forward_variables_from(invoker, [ "testonly" ])
1145
1146   assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
1147   assert(defined(invoker.android_manifest))
1148   gen_dir = "$target_gen_dir/$target_name"
1149   base_path = "$gen_dir/$target_name"
1150   _build_config = "$target_gen_dir/$target_name.build_config"
1151   resources_zip_path = "$base_path.resources.zip"
1152   _all_resources_zip_path = "$base_path.resources.all.zip"
1153   jar_path = "$base_path.jar"
1154   _template_name = target_name
1155
1156   final_dex_path = "$gen_dir/classes.dex"
1157   final_dex_target_name = "${_template_name}__final_dex"
1158
1159   _final_apk_path = ""
1160   if (defined(invoker.final_apk_path)) {
1161     _final_apk_path = invoker.final_apk_path
1162   } else if (defined(invoker.apk_name)) {
1163     _final_apk_path = "$root_build_dir/apks/" + invoker.apk_name + ".apk"
1164   }
1165   _dist_jar_path_list =
1166       process_file_template(
1167           [ _final_apk_path ],
1168           "$root_build_dir/test.lib.java/{{source_name_part}}.jar")
1169   _dist_jar_path = _dist_jar_path_list[0]
1170   _final_apk_path_no_ext_list =
1171       process_file_template([ _final_apk_path ],
1172                             "{{source_dir}}/{{source_name_part}}")
1173   _final_apk_path_no_ext = _final_apk_path_no_ext_list[0]
1174   assert(_final_apk_path_no_ext != "")  # Mark as used.
1175
1176   _native_libs = []
1177
1178   _version_code = "1"
1179   if (defined(invoker.version_code)) {
1180     _version_code = invoker.version_code
1181   }
1182
1183   _version_name = "Developer Build"
1184   if (defined(invoker.version_name)) {
1185     _version_name = invoker.version_name
1186   }
1187   _keystore_path = android_keystore_path
1188   _keystore_name = android_keystore_name
1189   _keystore_password = android_keystore_password
1190
1191   if (defined(invoker.keystore_path)) {
1192     _keystore_path = invoker.keystore_path
1193     _keystore_name = invoker.keystore_name
1194     _keystore_password = invoker.keystore_password
1195   }
1196
1197   _srcjar_deps = []
1198   if (defined(invoker.srcjar_deps)) {
1199     _srcjar_deps += invoker.srcjar_deps
1200   }
1201
1202   _load_library_from_apk = false
1203
1204   # The dependency that makes the chromium linker, if any is needed.
1205   _chromium_linker_dep = []
1206
1207   if (defined(invoker.native_libs)) {
1208     _use_chromium_linker = false
1209     if (defined(invoker.use_chromium_linker)) {
1210       _use_chromium_linker =
1211           invoker.use_chromium_linker && chromium_linker_supported
1212       _chromium_linker_dep = [ "//base/android/linker:chromium_android_linker" ]
1213     }
1214
1215     if (defined(invoker.load_library_from_apk) &&
1216         invoker.load_library_from_apk) {
1217       _load_library_from_apk = true
1218       assert(_use_chromium_linker,
1219              "Loading library from the apk requires use" +
1220                  " of the Chromium linker.")
1221     }
1222
1223     _enable_relocation_packing = false
1224     if (defined(invoker.enable_relocation_packing) &&
1225         invoker.enable_relocation_packing) {
1226       _enable_relocation_packing = relocation_packing_supported
1227       assert(_use_chromium_linker,
1228              "Relocation packing requires use of the" + " Chromium linker.")
1229     }
1230
1231     if (is_component_build) {
1232       _native_libs += [ "$root_shlib_dir/libc++_shared.so" ]
1233       _chromium_linker_dep += [ "//build/android:cpplib_stripped" ]
1234     }
1235
1236     # Allow native_libs to be in the form "foo.so" or "foo.cr.so"
1237     _first_ext_removed =
1238         process_file_template(invoker.native_libs, "{{source_name_part}}")
1239     _native_libs += process_file_template(
1240             _first_ext_removed,
1241             "$root_shlib_dir/{{source_name_part}}$shlib_extension")
1242
1243     # Add in target_cpu so that other architectures are not accidentally
1244     # included when switching target_cpu without doing a clean build.
1245     _native_libs_dir = gen_dir + "/lib-$target_cpu"
1246
1247     if (_use_chromium_linker) {
1248       _native_libs +=
1249           [ "$root_shlib_dir/libchromium_android_linker$shlib_extension" ]
1250     }
1251
1252     _enable_relocation_packing = false
1253     if (_use_chromium_linker && defined(invoker.enable_relocation_packing) &&
1254         invoker.enable_relocation_packing) {
1255       _enable_relocation_packing = true
1256     }
1257
1258     _native_lib_version_rule = ""
1259     if (defined(invoker.native_lib_version_rule)) {
1260       _native_lib_version_rule = invoker.native_lib_version_rule
1261     }
1262     _native_lib_version_arg = "\"\""
1263     if (defined(invoker.native_lib_version_arg)) {
1264       _native_lib_version_arg = invoker.native_lib_version_arg
1265     }
1266   }
1267
1268   _android_manifest_deps = []
1269   if (defined(invoker.android_manifest_dep)) {
1270     _android_manifest_deps = [ invoker.android_manifest_dep ]
1271   }
1272   _android_manifest = invoker.android_manifest
1273
1274   _rebased_build_config = rebase_path(_build_config, root_build_dir)
1275   _create_abi_split =
1276       defined(invoker.create_abi_split) && invoker.create_abi_split
1277   _create_density_splits =
1278       defined(invoker.create_density_splits) && invoker.create_density_splits
1279   _create_language_splits =
1280       defined(invoker.language_splits) && invoker.language_splits != []
1281
1282   # Help GN understand that _create_abi_split is not unused (bug in GN).
1283   assert(_create_abi_split || true)
1284
1285   build_config_target = "${_template_name}__build_config"
1286   write_build_config(build_config_target) {
1287     forward_variables_from(invoker, [ "apk_under_test" ])
1288     type = "android_apk"
1289     dex_path = final_dex_path
1290     resources_zip = resources_zip_path
1291     build_config = _build_config
1292     android_manifest = _android_manifest
1293
1294     deps = _chromium_linker_dep + _android_manifest_deps
1295     if (defined(invoker.deps)) {
1296       deps += invoker.deps
1297     }
1298
1299     native_libs = _native_libs
1300   }
1301
1302   _final_deps = []
1303   _incremental_final_deps = []
1304
1305   process_resources_target = "${_template_name}__process_resources"
1306   process_resources(process_resources_target) {
1307     forward_variables_from(invoker, [ "include_all_resources" ])
1308     srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
1309     r_text_path = "${target_gen_dir}/${target_name}_R.txt"
1310     android_manifest = _android_manifest
1311     resource_dirs = [ "//build/android/ant/empty/res" ]
1312     zip_path = resources_zip_path
1313     all_resources_zip_path = _all_resources_zip_path
1314     generate_constant_ids = true
1315
1316     build_config = _build_config
1317     deps = _android_manifest_deps + [ ":$build_config_target" ]
1318     if (defined(invoker.deps)) {
1319       deps += invoker.deps
1320     }
1321   }
1322   _srcjar_deps += [ ":$process_resources_target" ]
1323
1324   if (_native_libs != []) {
1325     _enable_chromium_linker_tests = false
1326     if (defined(invoker.enable_chromium_linker_tests)) {
1327       _enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
1328     }
1329
1330     java_cpp_template("${_template_name}__native_libraries_java") {
1331       package_name = "org/chromium/base/library_loader"
1332       sources = [
1333         "//base/android/java/templates/NativeLibraries.template",
1334       ]
1335       inputs = [
1336         _build_config,
1337       ]
1338       deps = [
1339         ":$build_config_target",
1340       ]
1341       if (_native_lib_version_rule != "") {
1342         deps += [ _native_lib_version_rule ]
1343       }
1344
1345       defines = [
1346         "NATIVE_LIBRARIES_LIST=" +
1347             "@FileArg($_rebased_build_config:native:java_libraries_list)",
1348         "NATIVE_LIBRARIES_VERSION_NUMBER=$_native_lib_version_arg",
1349       ]
1350       if (_use_chromium_linker) {
1351         defines += [ "ENABLE_CHROMIUM_LINKER" ]
1352       }
1353       if (_load_library_from_apk) {
1354         defines += [ "ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE" ]
1355       }
1356       if (_enable_chromium_linker_tests) {
1357         defines += [ "ENABLE_CHROMIUM_LINKER_TESTS" ]
1358       }
1359     }
1360     _srcjar_deps += [ ":${_template_name}__native_libraries_java" ]
1361   }
1362
1363   java_target = "${_template_name}__java"
1364   java_library_impl(java_target) {
1365     forward_variables_from(invoker, [ "run_findbugs" ])
1366     supports_android = true
1367     requires_android = true
1368     override_build_config = _build_config
1369     deps = _android_manifest_deps + [ ":$build_config_target" ]
1370
1371     android_manifest = _android_manifest
1372     chromium_code = true
1373     if (defined(invoker.java_files)) {
1374       java_files = invoker.java_files
1375     } else if (defined(invoker.DEPRECATED_java_in_dir)) {
1376       DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
1377     } else {
1378       java_files = []
1379     }
1380     srcjar_deps = _srcjar_deps
1381     dex_path = base_path + ".dex.jar"
1382
1383     if (defined(invoker.deps)) {
1384       deps += invoker.deps
1385     }
1386   }
1387
1388   if (_dist_jar_path != "") {
1389     create_dist_target = "${_template_name}__create_dist_jar"
1390     _final_deps += [ ":$create_dist_target" ]
1391     _incremental_final_deps += [ ":$create_dist_target" ]
1392
1393     # TODO(cjhopman): This is only ever needed to calculate the list of tests to
1394     # run. See build/android/pylib/instrumentation/test_jar.py. We should be
1395     # able to just do that calculation at build time instead.
1396     action(create_dist_target) {
1397       script = "//build/android/gyp/create_dist_jar.py"
1398       depfile = "$target_gen_dir/$target_name.d"
1399       inputs = [
1400         _build_config,
1401       ]
1402       outputs = [
1403         depfile,
1404         _dist_jar_path,
1405       ]
1406       args = [
1407         "--depfile",
1408         rebase_path(depfile, root_build_dir),
1409         "--output",
1410         rebase_path(_dist_jar_path, root_build_dir),
1411         "--inputs=@FileArg($_rebased_build_config:dist_jar:dependency_jars)",
1412       ]
1413       inputs += [ jar_path ]
1414       _rebased_jar_path = rebase_path([ jar_path ], root_build_dir)
1415       args += [ "--inputs=$_rebased_jar_path" ]
1416       deps = [
1417         ":$build_config_target",  # Generates the build config file.
1418         ":$java_target",  # Generates the jar file.
1419       ]
1420     }
1421   }
1422
1423   dex("$final_dex_target_name") {
1424     deps = [
1425       ":$build_config_target",
1426       ":$java_target",
1427     ]
1428     sources = [
1429       jar_path,
1430     ]
1431     inputs = [
1432       _build_config,
1433     ]
1434     output = final_dex_path
1435     dex_arg_key = "${_rebased_build_config}:final_dex:dependency_dex_files"
1436     args = [ "--inputs=@FileArg($dex_arg_key)" ]
1437   }
1438
1439   if (_native_libs != []) {
1440     action("${_template_name}__prepare_native") {
1441       forward_variables_from(invoker,
1442                              [
1443                                "data_deps",
1444                                "public_deps",
1445                              ])
1446       script = "//build/android/gyp/pack_relocations.py"
1447       packed_libraries_dir = "$_native_libs_dir/$android_app_abi"
1448       depfile = "$target_gen_dir/$target_name.d"
1449       outputs = [
1450         depfile,
1451       ]
1452
1453       inputs = _native_libs
1454       deps = _chromium_linker_dep
1455
1456       inputs += [ _build_config ]
1457       deps += [ ":$build_config_target" ]
1458
1459       skip_packing_list = [
1460         "gdbserver",
1461         "libchromium_android_linker$shlib_extension",
1462       ]
1463
1464       enable_packing_arg = 0
1465       if (_enable_relocation_packing) {
1466         enable_packing_arg = 1
1467         deps += [ relocation_packer_target ]
1468       }
1469
1470       args = [
1471         "--depfile",
1472         rebase_path(depfile, root_build_dir),
1473         "--enable-packing=$enable_packing_arg",
1474         "--exclude-packing-list=$skip_packing_list",
1475         "--android-pack-relocations",
1476         rebase_path(relocation_packer_exe, root_build_dir),
1477         "--stripped-libraries-dir",
1478         rebase_path(root_build_dir, root_build_dir),
1479         "--packed-libraries-dir",
1480         rebase_path(packed_libraries_dir, root_build_dir),
1481         "--libraries=@FileArg(${_rebased_build_config}:native:libraries)",
1482         "--clear-dir",
1483       ]
1484
1485       if (defined(invoker.deps)) {
1486         deps += invoker.deps
1487       }
1488
1489       if (is_debug) {
1490         rebased_gdbserver = rebase_path([ android_gdbserver ], root_build_dir)
1491         inputs += [ android_gdbserver ]
1492         args += [ "--libraries=$rebased_gdbserver" ]
1493       }
1494     }
1495   }
1496
1497   _final_deps += [ ":${_template_name}__create" ]
1498   _incremental_final_deps += [ ":${_template_name}__create_incremental" ]
1499   create_apk("${_template_name}__create") {
1500     forward_variables_from(invoker, [ "language_splits" ])
1501     apk_path = _final_apk_path
1502     android_manifest = _android_manifest
1503     resources_zip = _all_resources_zip_path
1504     dex_path = final_dex_path
1505     load_library_from_apk = _load_library_from_apk
1506     create_density_splits = _create_density_splits
1507     if (defined(invoker.extensions_to_not_compress)) {
1508       extensions_to_not_compress = invoker.extensions_to_not_compress
1509     } else {
1510       # Allow icu data, v8 snapshots, and pak files to be loaded directly from
1511       # the .apk.
1512       # Note: These are actually suffix matches, not necessarily extensions.
1513       extensions_to_not_compress = ".dat,.bin,.pak"
1514     }
1515
1516     version_code = _version_code
1517     version_name = _version_name
1518
1519     keystore_name = _keystore_name
1520     keystore_path = _keystore_path
1521     keystore_password = _keystore_password
1522
1523     # This target generates the input file _all_resources_zip_path.
1524     deps = _android_manifest_deps + [
1525              ":$process_resources_target",
1526              ":$final_dex_target_name",
1527            ]
1528     if (defined(invoker.deps)) {
1529       deps += invoker.deps
1530     }
1531
1532     if (defined(invoker.asset_location)) {
1533       asset_location = invoker.asset_location
1534
1535       # We don't know the exact dependencies that create the assets in
1536       # |asset_location|; we depend on all caller deps until a better solution
1537       # is figured out (http://crbug.com/433330).
1538       if (defined(invoker.deps)) {
1539         deps += invoker.deps
1540       }
1541     }
1542
1543     if (_native_libs != [] && !_create_abi_split) {
1544       native_libs_dir = _native_libs_dir
1545       deps += [ ":${_template_name}__prepare_native" ]
1546     }
1547   }
1548
1549   if (_native_libs != [] && _create_abi_split) {
1550     _manifest_rule = "${_template_name}__split_manifest_abi_${android_app_abi}"
1551     generate_split_manifest(_manifest_rule) {
1552       main_manifest = _android_manifest
1553       out_manifest =
1554           "$gen_dir/split-manifests/${android_app_abi}/AndroidManifest.xml"
1555       split_name = "abi_${android_app_abi}"
1556       deps = _android_manifest_deps
1557     }
1558
1559     _apk_rule = "${_template_name}__split_apk_abi_${android_app_abi}"
1560     _final_deps += [ ":$_apk_rule" ]
1561
1562     # Don't add this to _incremental_final_deps since for incremental installs
1563     # we skip abi splits altogether.
1564     create_apk(_apk_rule) {
1565       apk_path = "${_final_apk_path_no_ext}-abi-${android_app_abi}.apk"
1566       base_path = "$gen_dir/$_apk_rule"
1567
1568       manifest_outputs = get_target_outputs(":${_manifest_rule}")
1569       android_manifest = manifest_outputs[1]
1570       load_library_from_apk = _load_library_from_apk
1571
1572       version_code = _version_code
1573       version_name = _version_name
1574
1575       keystore_name = _keystore_name
1576       keystore_path = _keystore_path
1577       keystore_password = _keystore_password
1578
1579       native_libs_dir = _native_libs_dir
1580       deps = [
1581         ":${_template_name}__prepare_native",
1582         ":${_manifest_rule}",
1583       ]
1584     }
1585   }
1586
1587   _create_incremental_script_rule_name = "${_template_name}__incremental_script"
1588   _incremental_final_deps += [ ":${_create_incremental_script_rule_name}" ]
1589   action(_create_incremental_script_rule_name) {
1590     script = "//build/android/gn/create_incremental_install_script.py"
1591     depfile = "$target_gen_dir/$target_name.d"
1592
1593     _generated_script_path =
1594         "${root_out_dir}/bin/install_incremental_${_template_name}"
1595     outputs = [
1596       depfile,
1597       _generated_script_path,
1598     ]
1599
1600     _rebased_apk_path_no_ext =
1601         rebase_path(_final_apk_path_no_ext, root_build_dir)
1602     _rebased_generated_script_path =
1603         rebase_path(_generated_script_path, root_build_dir)
1604     _rebased_depfile = rebase_path(depfile, root_build_dir)
1605     args = [
1606       "--apk-path=${_rebased_apk_path_no_ext}_incremental.apk",
1607       "--script-output-path=$_rebased_generated_script_path",
1608       "--depfile=$_rebased_depfile",
1609     ]
1610     if (defined(_native_libs_dir)) {
1611       _rebased_native_libs_dir = rebase_path(_native_libs_dir, root_build_dir)
1612       args += [ "--lib-dir=$_rebased_native_libs_dir/$android_app_abi" ]
1613     }
1614     if (_create_density_splits) {
1615       args += [ "--split=${_rebased_apk_path_no_ext}-density-*.apk" ]
1616     }
1617     if (_create_language_splits) {
1618       args += [ "--split=${_rebased_apk_path_no_ext}-language-*.apk" ]
1619     }
1620   }
1621
1622   group(target_name) {
1623     forward_variables_from(invoker, [ "data_deps" ])
1624     deps = _final_deps
1625   }
1626   group("${target_name}_incremental") {
1627     data_deps = []
1628     forward_variables_from(invoker, [ "data_deps" ])
1629     data_deps += [ "//build/android/pylib/device/commands" ]
1630     deps = _incremental_final_deps
1631   }
1632 }
1633
1634 # Declare an Android instrumentation test apk
1635 #
1636 # This target creates an Android instrumentation test apk.
1637 #
1638 # Variables
1639 #   android_manifest: Path to AndroidManifest.xml.
1640 #   data_deps: List of dependencies needed at runtime. These will be built but
1641 #     won't change the generated .apk in any way (in fact they may be built
1642 #     after the .apk is).
1643 #   deps: List of dependencies. All Android java resources and libraries in the
1644 #     "transitive closure" of these dependencies will be included in the apk.
1645 #     Note: this "transitive closure" actually only includes such targets if
1646 #     they are depended on through android_library or android_resources targets
1647 #     (and so not through builtin targets like 'action', 'group', etc).
1648 #   java_files: List of .java files to include in the apk.
1649 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
1650 #      will be added to java_files and be included in this apk.
1651 #   apk_name: Name for final apk.
1652 #   final_apk_path: Path to final built apk. Default is
1653 #     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
1654 #   native_libs: List paths of native libraries to include in this apk. If these
1655 #     libraries depend on other shared_library targets, those dependencies will
1656 #     also be included in the apk.
1657 #   apk_under_test: The apk being tested.
1658 #   isolate_file: Isolate file containing the list of test data dependencies.
1659 #
1660 #   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
1661 #     this directory will be included in the library. This is only supported to
1662 #     ease the gyp->gn conversion and will be removed in the future.
1663 #
1664 # Example
1665 #   instrumentation_test_apk("foo_test_apk") {
1666 #     android_manifest = "AndroidManifest.xml"
1667 #     apk_name = "FooTest"
1668 #     apk_under_test = "Foo"
1669 #     java_files = [
1670 #       "android/org/chromium/foo/FooTestCase.java",
1671 #       "android/org/chromium/foo/FooExampleTest.java",
1672 #     ]
1673 #     deps = [
1674 #       ":foo_test_support_java"
1675 #     ]
1676 #   }
1677 template("instrumentation_test_apk") {
1678   set_sources_assignment_filter([])
1679   testonly = true
1680   _template_name = target_name
1681
1682   if (defined(invoker.apk_name)) {
1683     test_runner_data_dep = [ ":${_template_name}__test_runner_script" ]
1684     test_runner_script("${_template_name}__test_runner_script") {
1685       forward_variables_from(invoker, [ "isolate_file" ])
1686       test_name = invoker.target_name
1687       test_type = "instrumentation"
1688       test_apk = invoker.apk_name
1689     }
1690   }
1691
1692   android_apk(target_name) {
1693     deps = []
1694     data_deps = []
1695     forward_variables_from(invoker, "*")
1696     data_deps += [
1697       "//testing/android/driver:driver_apk",
1698       "//tools/android/forwarder2",
1699       "//tools/android/md5sum",
1700     ]
1701     if (defined(test_runner_data_dep)) {
1702       data_deps += test_runner_data_dep
1703     }
1704     deps += [ "//testing/android/broker:broker_java" ]
1705     run_findbugs = false
1706   }
1707 }
1708
1709 # Declare an Android gtest apk
1710 #
1711 # This target creates an Android apk for running gtest-based unittests.
1712 #
1713 # Variables
1714 #   deps: Specifies the dependencies of this target. These will be passed to
1715 #     the underlying android_apk invocation and should include the java and
1716 #     resource dependencies of the apk.
1717 #   unittests_dep: This should be the label of the gtest native target. This
1718 #     target must be defined previously in the same file.
1719 #   unittests_binary: The basename of the library produced by the unittests_dep
1720 #     target. If unspecified, it assumes the name of the unittests_dep target
1721 #     (which will be correct unless that target specifies an "output_name".
1722 #     TODO(brettw) make this automatic by allowing get_target_outputs to
1723 #     support executables.
1724 #   apk_name: The name of the produced apk. If unspecified, it uses the name
1725 #             of the unittests_dep target postfixed with "_apk"
1726 #
1727 # Example
1728 #   unittest_apk("foo_unittests_apk") {
1729 #     deps = [ ":foo_java", ":foo_resources" ]
1730 #     unittests_dep = ":foo_unittests"
1731 #   }
1732 template("unittest_apk") {
1733   set_sources_assignment_filter([])
1734   testonly = true
1735
1736   assert(defined(invoker.unittests_dep), "Need unittests_dep for $target_name")
1737
1738   test_suite_name = get_label_info(invoker.unittests_dep, "name")
1739
1740   # This trivial assert is needed in case both unittests_binary and apk_name
1741   # are defined, as otherwise test_suite_name would not be used.
1742   assert(test_suite_name != "")
1743
1744   if (defined(invoker.unittests_binary)) {
1745     unittests_binary = invoker.unittests_binary
1746   } else {
1747     unittests_binary = "lib${test_suite_name}${shlib_extension}"
1748   }
1749
1750   if (defined(invoker.apk_name)) {
1751     apk_name = invoker.apk_name
1752   } else {
1753     apk_name = test_suite_name
1754   }
1755
1756   android_apk(target_name) {
1757     forward_variables_from(invoker, [ "asset_location" ])
1758     final_apk_path = "$root_build_dir/${apk_name}_apk/${apk_name}-debug.apk"
1759     java_files = [
1760       "//testing/android/native_test/java/src/org/chromium/native_test/NativeBrowserTestActivity.java",
1761       "//testing/android/native_test/java/src/org/chromium/native_test/NativeTestActivity.java",
1762       "//testing/android/native_test/java/src/org/chromium/native_test/NativeUnitTestActivity.java",
1763       "//testing/android/native_test/java/src/org/chromium/native_test/NativeTestInstrumentationTestRunner.java",
1764     ]
1765     android_manifest = "//testing/android/native_test/java/AndroidManifest.xml"
1766     native_libs = [ unittests_binary ]
1767     deps = [
1768       "//base:base_java",
1769       "//build/android/pylib/remote/device/dummy:remote_device_dummy_apk",
1770       "//testing/android/appurify_support:appurify_support_java",
1771       "//testing/android/reporter:reporter_java",
1772     ]
1773     if (defined(invoker.deps)) {
1774       deps += invoker.deps
1775     }
1776     data_deps = [ "//tools/android/md5sum" ]
1777     if (host_os == "linux") {
1778       data_deps += [ "//tools/android/forwarder2" ]
1779     }
1780     if (defined(invoker.data_deps)) {
1781       data_deps += invoker.data_deps
1782     }
1783   }
1784 }
1785
1786 # Generate .java files from .aidl files.
1787 #
1788 # This target will store the .java files in a srcjar and should be included in
1789 # an android_library or android_apk's srcjar_deps.
1790 #
1791 # Variables
1792 #   sources: Paths to .aidl files to compile.
1793 #   import_include: Path to directory containing .java files imported by the
1794 #     .aidl files.
1795 #   interface_file: Preprocessed aidl file to import.
1796 #
1797 # Example
1798 #   android_aidl("foo_aidl") {
1799 #     import_include = "java/src"
1800 #     sources = [
1801 #       "java/src/com/foo/bar/FooBarService.aidl",
1802 #       "java/src/com/foo/bar/FooBarServiceCallback.aidl",
1803 #     ]
1804 #   }
1805 template("android_aidl") {
1806   set_sources_assignment_filter([])
1807   forward_variables_from(invoker, [ "testonly" ])
1808
1809   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
1810   aidl_path = "${android_sdk_build_tools}/aidl"
1811   framework_aidl = "$android_sdk/framework.aidl"
1812
1813   action(target_name) {
1814     script = "//build/android/gyp/aidl.py"
1815     sources = invoker.sources
1816
1817     imports = [ framework_aidl ]
1818     if (defined(invoker.interface_file)) {
1819       assert(invoker.interface_file != "")
1820       imports += [ invoker.interface_file ]
1821     }
1822
1823     inputs = [ aidl_path ] + imports
1824
1825     depfile = "${target_gen_dir}/${target_name}.d"
1826     outputs = [
1827       depfile,
1828       srcjar_path,
1829     ]
1830     rebased_imports = rebase_path(imports, root_build_dir)
1831     args = [
1832       "--depfile",
1833       rebase_path(depfile, root_build_dir),
1834       "--aidl-path",
1835       rebase_path(aidl_path, root_build_dir),
1836       "--imports=$rebased_imports",
1837       "--srcjar",
1838       rebase_path(srcjar_path, root_build_dir),
1839     ]
1840     if (defined(invoker.import_include) && invoker.import_include != "") {
1841       # TODO(cjhopman): aidl supports creating a depfile. We should be able to
1842       # switch to constructing a depfile for the overall action from that
1843       # instead of having all the .java files in the include paths as inputs.
1844       rebased_import_includes =
1845           rebase_path([ invoker.import_include ], root_build_dir)
1846       args += [ "--includes=$rebased_import_includes" ]
1847
1848       _java_files_build_rel =
1849           exec_script("//build/android/gyp/find.py",
1850                       rebase_path([ invoker.import_include ], root_build_dir),
1851                       "list lines")
1852       _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
1853       inputs += _java_files
1854     }
1855     args += rebase_path(sources, root_build_dir)
1856   }
1857 }
1858
1859 # Creates a dist directory for a native executable.
1860 #
1861 # Running a native executable on a device requires all the shared library
1862 # dependencies of that executable. To make it easier to install and run such an
1863 # executable, this will create a directory containing the native exe and all
1864 # it's library dependencies.
1865 #
1866 # Note: It's usually better to package things as an APK than as a native
1867 # executable.
1868 #
1869 # Variables
1870 #   dist_dir: Directory for the exe and libraries. Everything in this directory
1871 #     will be deleted before copying in the exe and libraries.
1872 #   binary: Path to (stripped) executable.
1873 #
1874 # Example
1875 #   create_native_executable_dist("foo_dist") {
1876 #     dist_dir = "$root_build_dir/foo_dist"
1877 #     binary = "$root_build_dir/foo"
1878 #     deps = [ ":the_thing_that_makes_foo" ]
1879 #   }
1880 template("create_native_executable_dist") {
1881   set_sources_assignment_filter([])
1882   forward_variables_from(invoker, [ "testonly" ])
1883
1884   dist_dir = invoker.dist_dir
1885   binary = invoker.binary
1886   template_name = target_name
1887
1888   libraries_list =
1889       "${target_gen_dir}/${template_name}_library_dependencies.list"
1890
1891   find_deps_target_name = "${template_name}__find_library_dependencies"
1892   copy_target_name = "${template_name}__copy_libraries_and_exe"
1893
1894   action(find_deps_target_name) {
1895     forward_variables_from(invoker, [ "deps" ])
1896     visibility = [ ":$copy_target_name" ]
1897
1898     script = "//build/android/gyp/write_ordered_libraries.py"
1899     depfile = "$target_gen_dir/$target_name.d"
1900     inputs = [
1901       binary,
1902       android_readelf,
1903     ]
1904     outputs = [
1905       depfile,
1906       libraries_list,
1907     ]
1908     rebased_binaries = rebase_path([ binary ], root_build_dir)
1909     args = [
1910       "--depfile",
1911       rebase_path(depfile, root_build_dir),
1912       "--input-libraries=$rebased_binaries",
1913       "--libraries-dir",
1914       rebase_path(root_shlib_dir, root_build_dir),
1915       "--output",
1916       rebase_path(libraries_list, root_build_dir),
1917       "--readelf",
1918       rebase_path(android_readelf, root_build_dir),
1919     ]
1920   }
1921
1922   copy_ex(copy_target_name) {
1923     visibility = [ ":$template_name" ]
1924
1925     clear_dir = true
1926     inputs = [
1927       binary,
1928       libraries_list,
1929     ]
1930     dest = dist_dir
1931     rebased_binaries_list = rebase_path([ binary ], root_build_dir)
1932     rebased_libraries_list = rebase_path(libraries_list, root_build_dir)
1933     args = [
1934       "--files=$rebased_binaries_list",
1935       "--files=@FileArg($rebased_libraries_list:lib_paths)",
1936     ]
1937
1938     deps = [
1939       ":$find_deps_target_name",
1940     ]
1941     if (defined(invoker.deps)) {
1942       deps += invoker.deps
1943     }
1944   }
1945
1946   group(template_name) {
1947     forward_variables_from(invoker, [ "visibility" ])
1948     deps = [
1949       ":$copy_target_name",
1950     ]
1951   }
1952 }
1953
1954 # Compile a protocol buffer to java.
1955 #
1956 # This generates java files from protocol buffers and creates an Android library
1957 # containing the classes.
1958 #
1959 # Variables
1960 #   sources: Paths to .proto files to compile.
1961 #   proto_path: Root directory of .proto files.
1962 #
1963 # Example:
1964 #  proto_java_library("foo_proto_java") {
1965 #    proto_path = [ "src/foo" ]
1966 #    sources = [ "$proto_path/foo.proto" ]
1967 #  }
1968 template("proto_java_library") {
1969   set_sources_assignment_filter([])
1970   forward_variables_from(invoker, [ "testonly" ])
1971   _protoc_dep = "//third_party/android_protobuf:android_protoc($host_toolchain)"
1972   _protoc_out_dir = get_label_info(_protoc_dep, "root_out_dir")
1973   _protoc_bin = "$_protoc_out_dir/android_protoc"
1974   _proto_path = invoker.proto_path
1975
1976   _template_name = target_name
1977
1978   action("${_template_name}__protoc_java") {
1979     srcjar_path = "$target_gen_dir/$target_name.srcjar"
1980     script = "//build/protoc_java.py"
1981     deps = [
1982       _protoc_dep,
1983     ]
1984     sources = invoker.sources
1985     depfile = "$target_gen_dir/$target_name.d"
1986     outputs = [
1987       depfile,
1988       srcjar_path,
1989     ]
1990     args = [
1991              "--depfile",
1992              rebase_path(depfile, root_build_dir),
1993              "--protoc",
1994              rebase_path(_protoc_bin, root_build_dir),
1995              "--proto-path",
1996              rebase_path(_proto_path, root_build_dir),
1997              "--srcjar",
1998              rebase_path(srcjar_path, root_build_dir),
1999            ] + rebase_path(sources, root_build_dir)
2000   }
2001
2002   android_library(target_name) {
2003     java_files = []
2004     srcjar_deps = [ ":${_template_name}__protoc_java" ]
2005     deps = [
2006       "//third_party/android_protobuf:protobuf_nano_javalib",
2007     ]
2008   }
2009 }
2010
2011 # TODO(GYP): implement this.
2012 template("uiautomator_test") {
2013   set_sources_assignment_filter([])
2014   forward_variables_from(invoker, [ "testonly" ])
2015   assert(target_name != "")
2016   assert(invoker.deps != [] || true)
2017   group(target_name) {
2018   }
2019 }