Update from https://crrev.com/333737

build/config/android/rules.gni

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import("//base/android/linker/config.gni")
 import("//build/config/android/config.gni")
 import("//build/config/android/internal_rules.gni")
+import("//third_party/android_platform/config.gni")
 import("//tools/grit/grit_rule.gni")
-import("//tools/relocation_packer/config.gni")
 
 assert(is_android)
 
 # Declare a jni target
 #
 # This target generates the native jni bindings for a set of .java files.
 #
 # See base/android/jni_generator/jni_generator.py for more info about the
 # format of generating JNI bindings.
 #
@@ skipping 226 matching lines @@
 
   assert(defined(invoker.sources))
   package_name = invoker.package_name + ""
 
   if (defined(invoker.include_path)) {
     include_path = invoker.include_path + ""
   } else {
     include_path = "//"
   }
 
-  action_foreach("${target_name}__apply_gcc") {
+  apply_gcc_target_name = "${target_name}__apply_gcc"
+  zip_srcjar_target_name = "${target_name}__zip_srcjar"
+  final_target_name = target_name
+
+  action_foreach(apply_gcc_target_name) {
+    visibility = [ ":$zip_srcjar_target_name" ]
     script = "//build/android/gyp/gcc_preprocess.py"
     if (defined(invoker.inputs)) {
       inputs = invoker.inputs + []
     }
     depfile = "${target_gen_dir}/${target_name}_{{source_name_part}}.d"
 
     sources = invoker.sources
 
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
+    if (defined(invoker.public_deps)) {
+      public_deps = invoker.public_deps
+    }
+    if (defined(invoker.data_deps)) {
+      data_deps = invoker.data_deps
+    }
+
     gen_dir =
         "${target_gen_dir}/${target_name}/java_cpp_template/${package_name}"
     gcc_template_output_pattern = "${gen_dir}/{{source_name_part}}.java"
 
     outputs = [
       depfile,
       gcc_template_output_pattern,
     ]
 
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--include-path",
       rebase_path(include_path, root_build_dir),
       "--output",
       rebase_path(gen_dir, root_build_dir) + "/{{source_name_part}}.java",
       "--template={{source}}",
     ]
 
     if (defined(invoker.defines)) {
       foreach(def, invoker.defines) {
         args += [
           "--defines",
           def,
         ]
       }
     }
   }
 
-  apply_gcc_outputs = get_target_outputs(":${target_name}__apply_gcc")
-  base_gen_dir = get_label_info(":${target_name}__apply_gcc", "target_gen_dir")
+  apply_gcc_outputs = get_target_outputs(":$apply_gcc_target_name")
+  base_gen_dir = get_label_info(":$apply_gcc_target_name", "target_gen_dir")
 
   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
-  zip("${target_name}__zip_srcjar") {
+  zip(zip_srcjar_target_name) {
+    visibility = [ ":$final_target_name" ]
     inputs = apply_gcc_outputs
     output = srcjar_path
     base_dir = base_gen_dir
+    deps = [
+      ":$apply_gcc_target_name",
+    ]
   }
 
-  group(target_name) {
+  group(final_target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
     deps = [
-      ":${target_name}__zip_srcjar",
+      ":$zip_srcjar_target_name",
     ]
   }
 }
 
 # Declare a target for generating Java classes from C++ enums.
 #
 # This target generates Java files from C++ enums using a script.
 #
 # This target will create a single .srcjar. Adding this target to an
 # android_library target's srcjar_deps will make the generated java files be
@@ skipping 20 matching lines @@
 #   }
 template("java_cpp_enum") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   assert(defined(invoker.sources))
   assert(defined(invoker.outputs))
 
-  action("${target_name}__generate_enum") {
+  generate_enum_target_name = "${target_name}__generate_enum"
+  zip_srcjar_target_name = "${target_name}__zip_srcjar"
+  final_target_name = target_name
+
+  action(generate_enum_target_name) {
+    visibility = [ ":$zip_srcjar_target_name" ]
+
     # The sources aren't compiled so don't check their dependencies.
     check_includes = false
 
     sources = invoker.sources
     script = "//build/android/gyp/java_cpp_enum.py"
     gen_dir = "${target_gen_dir}/${target_name}/enums"
     outputs =
         get_path_info(rebase_path(invoker.outputs, ".", gen_dir), "abspath")
 
     args = []
     foreach(output, rebase_path(outputs, root_build_dir)) {
       args += [
         "--assert_file",
         output,
       ]
     }
     args += [ rebase_path(gen_dir, root_build_dir) ]
     args += rebase_path(invoker.sources, root_build_dir)
   }
 
-  generate_enum_outputs = get_target_outputs(":${target_name}__generate_enum")
-  base_gen_dir =
-      get_label_info(":${target_name}__generate_enum", "target_gen_dir")
+  generate_enum_outputs = get_target_outputs(":$generate_enum_target_name")
+  base_gen_dir = get_label_info(":$generate_enum_target_name", "target_gen_dir")
 
   srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
-  zip("${target_name}__zip_srcjar") {
+  zip(zip_srcjar_target_name) {
+    visibility = [ ":$final_target_name" ]
     inputs = generate_enum_outputs
     output = srcjar_path
     base_dir = base_gen_dir
+    deps = [
+      ":$generate_enum_target_name",
+    ]
   }
 
-  group(target_name) {
+  group(final_target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
     deps = [
-      ":${target_name}__zip_srcjar",
+      ":$zip_srcjar_target_name",
     ]
   }
 }
 
 # Declare a target for processing a Jinja template.
 #
 # Variables
 #   input: The template file to be processed.
 #   output: Where to save the result.
 #   variables: (Optional) A list of variables to make available to the template
 #     processing environment, e.g. ["name=foo", "color=red"].
 #
 # Example
 #   jinja_template("chrome_shell_manifest") {
 #     input = "shell/java/AndroidManifest.xml"
 #     output = "$target_gen_dir/AndroidManifest.xml"
 #   }
 template("jinja_template") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   assert(defined(invoker.input))
   assert(defined(invoker.output))
 
   action(target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+
     sources = [
       invoker.input,
     ]
     script = "//build/android/gyp/jinja_template.py"
     depfile = "$target_gen_dir/$target_name.d"
 
     outputs = [
       depfile,
       invoker.output,
     ]
@@ skipping 97 matching lines @@
 # own dependencies.
 #
 # Variables
 #   deps: Specifies the dependencies of this target. Any Android resources
 #     listed in deps will be included by libraries/apks that depend on this
 #     target.
 #   resource_dirs: List of directories containing resources for this target.
 #   android_manifest: AndroidManifest.xml for this target. Defaults to
 #     //build/android/AndroidManifest.xml.
 #   custom_package: java package for generated .java files.
-#   v14_verify_only: If true, don't generate v14/v17 resources and just verify
-#     that the resources are v14-compliant (see
-#     build/android/gyp/generate_v14_compatible_resources.py). Defaults to
-#     false.
+#   v14_skip: If true, don't run v14 resource generator on this. Defaults to
+#     false. (see build/android/gyp/generate_v14_compatible_resources.py)
+#
 #   shared_resources: If true make a resource package that can be loaded by a
 #     different application at runtime to access the package's resources.
 #
 
 # Example
 #   android_resources("foo_resources") {
 #     deps = [":foo_strings_grd"]
 #     resource_dirs = ["res"]
 #     custom_package = "org.chromium.foo"
 #   }
 template("android_resources") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   assert(defined(invoker.resource_dirs))
   assert(defined(invoker.android_manifest) || defined(invoker.custom_package))
 
   base_path = "$target_gen_dir/$target_name"
   zip_path = base_path + ".resources.zip"
   srcjar_path = base_path + ".srcjar"
   r_text_path = base_path + "_R.txt"
   build_config = base_path + ".build_config"
 
-  write_build_config("${target_name}__build_config") {
+  build_config_target_name = "${target_name}__build_config"
+  process_resources_target_name = "${target_name}__process_resources"
+  final_target_name = target_name
+
+  write_build_config(build_config_target_name) {
+    visibility = [ ":$process_resources_target_name" ]
+
     type = "android_resources"
     resources_zip = zip_path
     srcjar = srcjar_path
     r_text = r_text_path
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
     if (defined(invoker.android_manifest)) {
       android_manifest = invoker.android_manifest
     }
     if (defined(invoker.custom_package)) {
       custom_package = invoker.custom_package
     }
   }
 
   android_manifest = "//build/android/AndroidManifest.xml"
   if (defined(invoker.android_manifest)) {
     android_manifest = invoker.android_manifest
   }
 
-  process_resources("${target_name}__process_resources") {
+  process_resources(process_resources_target_name) {
+    visibility = [ ":$final_target_name" ]
+
     resource_dirs = invoker.resource_dirs
     if (defined(invoker.custom_package)) {
       custom_package = invoker.custom_package
     }
 
-    if (defined(invoker.v14_verify_only)) {
-      v14_verify_only = invoker.v14_verify_only
+    if (defined(invoker.v14_skip)) {
+      v14_skip = invoker.v14_skip
     }
 
     if (defined(invoker.shared_resources)) {
       shared_resources = invoker.shared_resources
     }
+
+    deps = [
+      ":$build_config_target_name",
+    ]
+    if (defined(invoker.deps)) {
+      # Invoker may have added deps that generate the input resources.
+      deps += invoker.deps
+    }
   }
 
-  group(target_name) {
+  group(final_target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
     deps = [
-      ":${target_name}__build_config",
       ":${target_name}__process_resources",
     ]
   }
 }
 
 # Declare a target that generates localized strings.xml from a .grd file.
 #
 # If this target is included in the deps of an android resources/library/apk,
 # the strings.xml will be included with that target.
 #
@@ skipping 40 matching lines @@
   }
 
   # This needs to get outputs from grit's internal target, not the final
   # source_set.
   generate_strings_outputs = get_target_outputs(":${grit_target_name}_grit")
 
   zip("${target_name}__zip") {
     base_dir = grit_output_dir
     inputs = generate_strings_outputs
     output = resources_zip
+    deps = [
+      ":$grit_target_name",
+    ]
   }
 
   group(target_name) {
     deps = [
       ":${target_name}__build_config",
       ":${target_name}__zip",
     ]
   }
 }
 
@@ skipping 16 matching lines @@
 template("java_strings_grd_prebuilt") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   base_path = "$target_gen_dir/$target_name"
   resources_zip = base_path + ".resources.zip"
   build_config = base_path + ".build_config"
 
-  write_build_config("${target_name}__build_config") {
+  build_config_target_name = "${target_name}__build_config"
+  zip_target_name = "${target_name}__zip"
+  final_target_name = target_name
+
+  write_build_config(build_config_target_name) {
+    visibility = [ ":$zip_target_name" ]
     type = "android_resources"
+  }
+
+  zip(zip_target_name) {
+    visibility = [ ":$final_target_name" ]
+
+    base_dir = invoker.grit_output_dir
+    inputs = rebase_path(invoker.generated_files, ".", base_dir)
+    output = resources_zip
+    deps = [
+      ":$build_config_target_name",
+    ]
     if (defined(invoker.deps)) {
-      deps = invoker.deps
+      deps += invoker.deps
     }
   }
 
-  zip("${target_name}__zip") {
-    base_dir = invoker.grit_output_dir
-    inputs = rebase_path(invoker.generated_files, ".", base_dir)
-    output = resources_zip
-  }
-
-  group(target_name) {
+  group(final_target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
     deps = [
-      ":${target_name}__build_config",
-      ":${target_name}__zip",
+      ":$zip_target_name",
     ]
   }
 }
 
 # Declare a Java executable target
 #
 # This target creates an executable from java code and libraries. The executable
 # will be in the output folder's /bin/ directory.
 #
 # Variables
 #   deps: Specifies the dependencies of this target. Java targets in this list
 #     will be included in the executable (and the javac classpath).
 #
 #   java_files: List of .java files included in this library.
 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 #     will be added to java_files and be included in this library.
 #   srcjars: List of srcjars to be included in this library, together with the
 #     ones obtained from srcjar_deps.
 #
 #   bypass_platform_checks: Disables checks about cross-platform (Java/Android)
 #     dependencies for this target. This will allow depending on an
 #     android_library target, for example.
 #
 #   chromium_code: If true, extra analysis warning/errors will be enabled.
 #
-#   datadeps, testonly
+#   data_deps, testonly
 #
 # Example
 #   java_binary("foo") {
 #     java_files = [ "org/chromium/foo/FooMain.java" ]
 #     deps = [ ":bar_java" ]
 #     main_class = "org.chromium.foo.FooMain"
 #   }
 template("java_binary") {
   set_sources_assignment_filter([])
 
   # TODO(cjhopman): This should not act like a java_library for dependents (i.e.
   # dependents shouldn't get the jar in their classpath, etc.).
   java_library_impl(target_name) {
     if (defined(invoker.DEPRECATED_java_in_dir)) {
       DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
     }
     if (defined(invoker.chromium_code)) {
       chromium_code = invoker.chromium_code
     }
-    if (defined(invoker.datadeps)) {
-      deps = invoker.datadeps
+    if (defined(invoker.data_deps)) {
+      deps = invoker.data_deps
     }
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
     if (defined(invoker.java_files)) {
       java_files = invoker.java_files
     }
     if (defined(invoker.srcjar_deps)) {
       srcjar_deps = invoker.srcjar_deps
     }
@@ skipping 92 matching lines @@
 #     be used to remove unwanted parts of the library.
 #   proguard_config: Path to the proguard config for preprocessing.
 #
 #   supports_android: If true, Android targets (android_library, android_apk)
 #     may depend on this target. Note: if true, this target must only use the
 #     subset of Java available on Android.
 #   bypass_platform_checks: Disables checks about cross-platform (Java/Android)
 #     dependencies for this target. This will allow depending on an
 #     android_library target, for example.
 #
-#   datadeps, testonly
+#   data_deps, testonly
 #
 # Example
 #   java_library("foo_java") {
 #     java_files = [
 #       "org/chromium/foo/Foo.java",
 #       "org/chromium/foo/FooInterface.java",
 #       "org/chromium/foo/FooService.java",
 #     ]
 #     deps = [
 #       ":bar_java"
 #     ]
 #     srcjar_deps = [
 #       ":foo_generated_enum"
 #     ]
 #     jar_excluded_patterns = [
 #       "*/FooService.class", "*/FooService##*.class"
 #     ]
 #   }
 template("java_library") {
   set_sources_assignment_filter([])
   java_library_impl(target_name) {
     if (defined(invoker.DEPRECATED_java_in_dir)) {
       DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
     }
     if (defined(invoker.chromium_code)) {
       chromium_code = invoker.chromium_code
     }
-    if (defined(invoker.datadeps)) {
-      deps = invoker.datadeps
+    if (defined(invoker.data_deps)) {
+      deps = invoker.data_deps
     }
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
     if (defined(invoker.jar_excluded_patterns)) {
       jar_excluded_patterns = invoker.jar_excluded_patterns
     }
     if (defined(invoker.java_files)) {
       java_files = invoker.java_files
     }
@@ skipping 114 matching lines @@
   set_sources_assignment_filter([])
   assert(!defined(invoker.jar_path),
          "android_library does not support a custom jar path")
   java_library_impl(target_name) {
     if (defined(invoker.DEPRECATED_java_in_dir)) {
       DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
     }
     if (defined(invoker.chromium_code)) {
       chromium_code = invoker.chromium_code
     }
-    if (defined(invoker.datadeps)) {
-      deps = invoker.datadeps
+    if (defined(invoker.data_deps)) {
+      deps = invoker.data_deps
     }
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
     if (defined(invoker.jar_excluded_patterns)) {
       jar_excluded_patterns = invoker.jar_excluded_patterns
     }
     if (defined(invoker.java_files)) {
       java_files = invoker.java_files
     }
@@ skipping 98 matching lines @@
   }
 }
 
 # Declare an Android apk target
 #
 # This target creates an Android APK containing java code, resources, assets,
 # and (possibly) native libraries.
 #
 # Variables
 #   android_manifest: Path to AndroidManifest.xml.
-#   datadeps: List of dependencies needed at runtime. These will be built but
+#   data_deps: List of dependencies needed at runtime. These will be built but
 #     won't change the generated .apk in any way (in fact they may be built
 #     after the .apk is).
 #   deps: List of dependencies. All Android java resources and libraries in the
 #     "transitive closure" of these dependencies will be included in the apk.
 #     Note: this "transitive closure" actually only includes such targets if
 #     they are depended on through android_library or android_resources targets
 #     (and so not through builtin targets like 'action', 'group', etc).
 #   java_files: List of .java files to include in the apk.
 #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
 #      will be added to java_files and be included in this apk.
@@ skipping 36 matching lines @@
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
   assert(defined(invoker.android_manifest))
   gen_dir = "$target_gen_dir/$target_name"
   base_path = "$gen_dir/$target_name"
   _build_config = "$target_gen_dir/$target_name.build_config"
   resources_zip_path = "$base_path.resources.zip"
-  all_resources_zip_path = "$base_path.resources.all.zip"
+  _all_resources_zip_path = "$base_path.resources.all.zip"
   jar_path = "$base_path.jar"
+  _template_name = target_name
+
   final_dex_path = "$gen_dir/classes.dex"
-  _template_name = target_name
+  final_dex_target_name = "${_template_name}__final_dex"
+
   _final_apk_path = ""
   if (defined(invoker.final_apk_path)) {
     _final_apk_path = invoker.final_apk_path
   } else if (defined(invoker.apk_name)) {
     _final_apk_path = "$root_build_dir/apks/" + invoker.apk_name + ".apk"
   }
   _dist_jar_path_list =
       process_file_template(
           [ _final_apk_path ],
           "$root_build_dir/test.lib.java/{{source_name_part}}.jar")
   _dist_jar_path = _dist_jar_path_list[0]
 
   _native_libs = []
 
+  _version_code = "1"
+  if (defined(invoker.version_code)) {
+    _version_code = invoker.version_code
+  }
+
+  _version_name = "Developer Build"
+  if (defined(invoker.version_name)) {
+    _version_name = invoker.version_name
+  }
   _keystore_path = android_default_keystore_path
   _keystore_name = android_default_keystore_name
   _keystore_password = android_default_keystore_password
 
   if (defined(invoker.keystore_path)) {
     _keystore_path = invoker.keystore_path
     _keystore_name = invoker.keystore_name
     _keystore_password = invoker.keystore_password
   }
 
   _srcjar_deps = []
   if (defined(invoker.srcjar_deps)) {
     _srcjar_deps += invoker.srcjar_deps
   }
 
   _load_library_from_apk = false
 
+  # The dependency that makes the chromium linker, if any is needed.
+  _chromium_linker_dep = []
+
   if (defined(invoker.native_libs)) {
     _use_chromium_linker = false
     if (defined(invoker.use_chromium_linker)) {
       _use_chromium_linker =
           invoker.use_chromium_linker && chromium_linker_supported
+      _chromium_linker_dep = [ "//base/android/linker:chromium_android_linker" ]
     }
 
     if (defined(invoker.load_library_from_apk) &&
         invoker.load_library_from_apk) {
       _load_library_from_apk = true
       assert(_use_chromium_linker,
              "Loading library from the apk requires use" +
                  " of the Chromium linker.")
     }
 
@@ skipping 23 matching lines @@
     }
 
     _native_lib_version_name = ""
     if (defined(invoker.native_lib_version_name)) {
       _native_lib_version_name = invoker.native_lib_version_name
     }
   }
 
   _android_manifest = invoker.android_manifest
   _rebased_build_config = rebase_path(_build_config, root_build_dir)
+  _create_abi_split =
+      defined(invoker.create_abi_split) && invoker.create_abi_split
+  _create_density_splits =
+      defined(invoker.create_density_splits) && invoker.create_density_splits
 
-  write_build_config("${_template_name}__build_config") {
+  # Help GN understand that _create_abi_split is not unused (bug in GN).
+  assert(_create_abi_split || true)
+
+  build_config_target = "${_template_name}__build_config"
+  write_build_config(build_config_target) {
     type = "android_apk"
     dex_path = final_dex_path
     resources_zip = resources_zip_path
     build_config = _build_config
     android_manifest = _android_manifest
 
+    deps = _chromium_linker_dep
     if (defined(invoker.deps)) {
-      deps = invoker.deps
+      deps += invoker.deps
     }
 
     if (defined(invoker.apk_under_test)) {
       apk_under_test = invoker.apk_under_test
     }
 
     native_libs = _native_libs
   }
 
   final_deps = []
 
-  final_deps += [ ":${_template_name}__process_resources" ]
-  process_resources("${_template_name}__process_resources") {
+  process_resources_target = "${_template_name}__process_resources"
+  final_deps += [ ":$process_resources_target" ]
+  process_resources(process_resources_target) {
     srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
     r_text_path = "${target_gen_dir}/${target_name}_R.txt"
     android_manifest = _android_manifest
     resource_dirs = [ "//build/android/ant/empty/res" ]
     zip_path = resources_zip_path
+    all_resources_zip_path = _all_resources_zip_path
     generate_constant_ids = true
-    build_config = _build_config
 
     if (defined(invoker.include_all_resources)) {
       include_all_resources = invoker.include_all_resources
     }
+
+    build_config = _build_config
+    deps = [
+      ":$build_config_target",
+    ]
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
   }
-  _srcjar_deps += [ ":${_template_name}__process_resources" ]
+  _srcjar_deps += [ ":$process_resources_target" ]
 
   if (_native_libs != []) {
     _enable_chromium_linker_tests = false
     if (defined(invoker.enable_chromium_linker_tests)) {
       _enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
     }
 
     java_cpp_template("${_template_name}__native_libraries_java") {
       package_name = "org/chromium/base/library_loader"
       sources = [
         "//base/android/java/templates/NativeLibraries.template",
       ]
       inputs = [
         _build_config,
       ]
+      deps = [
+        ":$build_config_target",
+      ]
 
       defines = [
         "NATIVE_LIBRARIES_LIST=" +
             "@FileArg($_rebased_build_config:native:java_libraries_list)",
         "NATIVE_LIBRARIES_VERSION_NUMBER=\"$_native_lib_version_name\"",
       ]
       if (_use_chromium_linker) {
         defines += [ "ENABLE_CHROMIUM_LINKER" ]
       }
       if (_load_library_from_apk) {
         defines += [ "ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE" ]
       }
       if (_enable_chromium_linker_tests) {
         defines += [ "ENABLE_CHROMIUM_LINKER_TESTS" ]
       }
     }
     _srcjar_deps += [ ":${_template_name}__native_libraries_java" ]
   }
 
-  final_deps += [ ":${_template_name}__java" ]
-  java_library_impl("${_template_name}__java") {
+  java_target = "${_template_name}__java"
+  final_deps += [ ":$java_target" ]
+  java_library_impl(java_target) {
     supports_android = true
     requires_android = true
     override_build_config = _build_config
+    deps = [
+      ":$build_config_target",
+    ]
+
     android_manifest = _android_manifest
     chromium_code = true
     if (defined(invoker.java_files)) {
       java_files = invoker.java_files
     } else if (defined(invoker.DEPRECATED_java_in_dir)) {
       DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
     } else {
       java_files = []
     }
     srcjar_deps = _srcjar_deps
     dex_path = base_path + ".dex.jar"
+
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
   }
 
   if (_dist_jar_path != "") {
-    final_deps += [ ":${_template_name}__create_dist_jar" ]
+    create_dist_target = "${_template_name}__create_dist_jar"
+    final_deps += [ ":$create_dist_target" ]
 
     # TODO(cjhopman): This is only ever needed to calculate the list of tests to
     # run. See build/android/pylib/instrumentation/test_jar.py. We should be
     # able to just do that calculation at build time instead.
-    action("${_template_name}__create_dist_jar") {
+    action(create_dist_target) {
       script = "//build/android/gyp/create_dist_jar.py"
       depfile = "$target_gen_dir/$target_name.d"
       inputs = [
         _build_config,
       ]
       outputs = [
         depfile,
         _dist_jar_path,
       ]
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         "--output",
         rebase_path(_dist_jar_path, root_build_dir),
         "--inputs=@FileArg($_rebased_build_config:dist_jar:dependency_jars)",
       ]
       inputs += [ jar_path ]
       _rebased_jar_path = rebase_path([ jar_path ], root_build_dir)
       args += [ "--inputs=$_rebased_jar_path" ]
+      deps = [
+        ":$build_config_target",  # Generates the build config file.
+        ":$java_target",  # Generates the jar file.
+      ]
     }
   }
 
-  final_deps += [ ":${_template_name}__final_dex" ]
-  dex("${_template_name}__final_dex") {
+  final_deps += [ ":$final_dex_target_name" ]
+  dex("$final_dex_target_name") {
     deps = [
-      ":${_template_name}__java",
+      ":$build_config_target",
+      ":$java_target",
     ]
     sources = [
       jar_path,
     ]
     inputs = [
       _build_config,
     ]
     output = final_dex_path
     dex_arg_key = "${_rebased_build_config}:final_dex:dependency_dex_files"
     args = [ "--inputs=@FileArg($dex_arg_key)" ]
   }
 
   if (_native_libs != []) {
     action("${_template_name}__prepare_native") {
       script = "//build/android/gyp/pack_arm_relocations.py"
       packed_libraries_dir = "$_native_libs_dir/$android_app_abi"
       depfile = "$target_gen_dir/$target_name.d"
       outputs = [
         depfile,
       ]
-      inputs = [ _build_config ] + _native_libs
-      deps = []
+
+      inputs = _native_libs
+      deps = _chromium_linker_dep
+
+      inputs += [ _build_config ]
+      deps += [ ":$build_config_target" ]
+
       skip_packing_list = [
         "gdbserver",
         "libchromium_android_linker.so",
       ]
 
       enable_packing_arg = 0
       if (_enable_relocation_packing) {
         enable_packing_arg = 1
         deps += [ relocation_packer_target ]
       }
 
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         "--enable-packing=$enable_packing_arg",
-        "--has-relocations-with-addends=$relocations_have_addends",
         "--exclude-packing-list=$skip_packing_list",
         "--android-pack-relocations",
         rebase_path(relocation_packer_exe, root_build_dir),
-        "--android-objcopy",
-        rebase_path(android_objcopy, root_build_dir),
         "--stripped-libraries-dir",
         rebase_path(root_build_dir, root_build_dir),
         "--packed-libraries-dir",
         rebase_path(packed_libraries_dir, root_build_dir),
         "--libraries=@FileArg(${_rebased_build_config}:native:libraries)",
         "--clear-dir",
       ]
 
+      if (defined(invoker.deps)) {
+        deps += invoker.deps
+      }
+      if (defined(invoker.public_deps)) {
+        public_deps = invoker.public_deps
+      }
+      if (defined(invoker.data_deps)) {
+        data_deps = invoker.data_deps
+      }
+
       if (is_debug) {
         rebased_gdbserver = rebase_path([ android_gdbserver ], root_build_dir)
         inputs += [ android_gdbserver ]
         args += [ "--libraries=$rebased_gdbserver" ]
       }
     }
   }
 
   final_deps += [ ":${_template_name}__create" ]
   create_apk("${_template_name}__create") {
     apk_path = _final_apk_path
     android_manifest = _android_manifest
-    resources_zip = all_resources_zip_path
+    resources_zip = _all_resources_zip_path
     dex_path = final_dex_path
     load_library_from_apk = _load_library_from_apk
+    create_density_splits = _create_density_splits
 
-    version_code = "1"
-    if (defined(invoker.version_code)) {
-      version_code = invoker.version_code
-    }
-
-    version_name = "Developer Build"
-    if (defined(invoker.version_name)) {
-      version_name = invoker.version_name
-    }
+    version_code = _version_code
+    version_name = _version_name
 
     keystore_name = _keystore_name
     keystore_path = _keystore_path
     keystore_password = _keystore_password
 
-    deps = []
+    # This target generates the input file _all_resources_zip_path.
+    deps = [
+      ":$process_resources_target",
+      ":$final_dex_target_name",
+    ]
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
+
     if (defined(invoker.asset_location)) {
       asset_location = invoker.asset_location
 
       # We don't know the exact dependencies that create the assets in
       # |asset_location|; we depend on all caller deps until a better solution
       # is figured out (http://crbug.com/433330).
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
     }
 
-    if (_native_libs != []) {
+    if (_native_libs != [] && !_create_abi_split) {
       native_libs_dir = _native_libs_dir
       deps += [ ":${_template_name}__prepare_native" ]
     }
   }
 
+  if (_native_libs != [] && _create_abi_split) {
+    _manifest_rule = "${_template_name}__split_manifest_abi_${android_app_abi}"
+    generate_split_manifest(_manifest_rule) {
+      main_manifest = _android_manifest
+      out_manifest =
+          "$gen_dir/split-manifests/${android_app_abi}/AndroidManifest.xml"
+      split_name = "abi_${android_app_abi}"
+    }
+
+    _apk_rule = "${_template_name}__split_apk_abi_${android_app_abi}"
+    final_deps += [ ":$_apk_rule" ]
+    create_apk(_apk_rule) {
+      _split_paths = process_file_template(
+              [ _final_apk_path ],
+              "{{source_dir}}/{{source_name_part}}-abi-${android_app_abi}.apk")
+      apk_path = _split_paths[0]
+      base_path = "$gen_dir/$_apk_rule"
+
+      manifest_outputs = get_target_outputs(":${_manifest_rule}")
+      android_manifest = manifest_outputs[1]
+      load_library_from_apk = _load_library_from_apk
+
+      version_code = _version_code
+      version_name = _version_name
+
+      keystore_name = _keystore_name
+      keystore_path = _keystore_path
+      keystore_password = _keystore_password
+
+      native_libs_dir = _native_libs_dir
+      deps = [
+        ":${_template_name}__prepare_native",
+      ]
+    }
+  }
+
   group(target_name) {
     deps = final_deps
-    if (defined(invoker.datadeps)) {
-      datadeps = invoker.datadeps
+    if (defined(invoker.data_deps)) {
+      data_deps = invoker.data_deps
     }
   }
 }
+
+# Declare an Android instrumentation test apk
+#
+# This target creates an Android instrumentation test apk.
+#
+# Variables
+#   android_manifest: Path to AndroidManifest.xml.
+#   data_deps: List of dependencies needed at runtime. These will be built but
+#     won't change the generated .apk in any way (in fact they may be built
+#     after the .apk is).
+#   deps: List of dependencies. All Android java resources and libraries in the
+#     "transitive closure" of these dependencies will be included in the apk.
+#     Note: this "transitive closure" actually only includes such targets if
+#     they are depended on through android_library or android_resources targets
+#     (and so not through builtin targets like 'action', 'group', etc).
+#   java_files: List of .java files to include in the apk.
+#   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
+#      will be added to java_files and be included in this apk.
+#   apk_name: Name for final apk.
+#   final_apk_path: Path to final built apk. Default is
+#     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
+#   native_libs: List paths of native libraries to include in this apk. If these
+#     libraries depend on other shared_library targets, those dependencies will
+#     also be included in the apk.
+#   apk_under_test: The apk being tested.
+#   isolate_file: Isolate file containing the list of test data dependencies.
+#
+#   DEPRECATED_java_in_dir: Directory containing java files. All .java files in
+#     this directory will be included in the library. This is only supported to
+#     ease the gyp->gn conversion and will be removed in the future.
+#
+# Example
+#   instrumentation_test_apk("foo_test_apk") {
+#     android_manifest = "AndroidManifest.xml"
+#     apk_name = "FooTest"
+#     apk_under_test = "Foo"
+#     java_files = [
+#       "android/org/chromium/foo/FooTestCase.java",
+#       "android/org/chromium/foo/FooExampleTest.java",
+#     ]
+#     deps = [
+#       ":foo_test_support_java"
+#     ]
+#   }
+template("instrumentation_test_apk") {
+  set_sources_assignment_filter([])
+  testonly = true
+  _template_name = target_name
+
+  if (defined(invoker.apk_name)) {
+    test_runner_data_dep = [ ":${_template_name}__test_runner_script" ]
+    test_runner_script("${_template_name}__test_runner_script") {
+      test_name = invoker.target_name
+      test_type = "instrumentation"
+      test_apk = invoker.apk_name
+      if (defined(invoker.isolate_file)) {
+        isolate_file = invoker.isolate_file
+      }
+    }
+  }
+
+  android_apk(target_name) {
+    if (defined(invoker.android_manifest)) {
+      android_manifest = invoker.android_manifest
+    }
+    data_deps = [
+      "//testing/android/driver:driver_apk",
+      "//tools/android/forwarder2",
+      "//tools/android/md5sum",
+    ]
+    if (defined(test_runner_data_dep)) {
+      data_deps += test_runner_data_dep
+    }
+    if (defined(invoker.data_deps)) {
+      data_deps += invoker.data_deps
+    }
+    deps = [
+      "//testing/android/broker:broker_java",
+    ]
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
+    if (defined(invoker.java_files)) {
+      java_files = invoker.java_files
+    }
+    if (defined(invoker.srcjar_deps)) {
+      srcjar_deps = invoker.srcjar_deps
+    }
+    if (defined(invoker.apk_name)) {
+      apk_name = invoker.apk_name
+    }
+    if (defined(invoker.final_apk_path)) {
+      final_apk_path = invoker.final_apk_path
+    }
+    if (defined(invoker.native_libs)) {
+      native_libs = invoker.native_libs
+    }
+    if (defined(invoker.apk_under_test)) {
+      apk_under_test = invoker.apk_under_test
+    }
+    if (defined(invoker.DEPRECATED_java_in_dir)) {
+      DEPRECATED_java_in_dir = invoker.DEPRECATED_java_in_dir
+    }
+  }
+}
 
 # Declare an Android gtest apk
 #
 # This target creates an Android apk for running gtest-based unittests.
 #
 # Variables
 #   deps: Specifies the dependencies of this target. These will be passed to
 #     the underlying android_apk invocation and should include the java and
 #     resource dependencies of the apk.
 #   unittests_dep: This should be the label of the gtest native target. This
@@ skipping 31 matching lines @@
 
   if (defined(invoker.apk_name)) {
     apk_name = invoker.apk_name
   } else {
     apk_name = test_suite_name
   }
 
   android_apk(target_name) {
     final_apk_path = "$root_build_dir/${apk_name}_apk/${apk_name}-debug.apk"
     java_files = [
+      "//testing/android/native_test/java/src/org/chromium/native_test/NativeBrowserTestActivity.java",
       "//testing/android/native_test/java/src/org/chromium/native_test/NativeTestActivity.java",
+      "//testing/android/native_test/java/src/org/chromium/native_test/NativeUnitTestActivity.java",
       "//testing/android/native_test/java/src/org/chromium/native_test/NativeTestInstrumentationTestRunner.java",
     ]
     android_manifest = "//testing/android/native_test/java/AndroidManifest.xml"
     native_libs = [ unittests_binary ]
     if (defined(invoker.asset_location)) {
       asset_location = invoker.asset_location
     }
     deps = [
       "//base:base_java",
       "//build/android/pylib/remote/device/dummy:remote_device_dummy_apk",
       "//testing/android/appurify_support:appurify_support_java",
     ]
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
-    datadeps = [
-      "//tools/android/md5sum",
-    ]
+    data_deps = [ "//tools/android/md5sum" ]
     if (host_os == "linux") {
-      datadeps += [ "//tools/android/forwarder2" ]
+      data_deps += [ "//tools/android/forwarder2" ]
     }
-    if (defined(invoker.datadeps)) {
-      datadeps += invoker.datadeps
+    if (defined(invoker.data_deps)) {
+      data_deps += invoker.data_deps
     }
   }
 }
 
 # Generate .java files from .aidl files.
 #
 # This target will store the .java files in a srcjar and should be included in
 # an android_library or android_apk's srcjar_deps.
 #
 # Variables
@@ skipping 78 matching lines @@
 #
 # Variables
 #   dist_dir: Directory for the exe and libraries. Everything in this directory
 #     will be deleted before copying in the exe and libraries.
 #   binary: Path to (stripped) executable.
 #
 # Example
 #   create_native_executable_dist("foo_dist") {
 #     dist_dir = "$root_build_dir/foo_dist"
 #     binary = "$root_build_dir/exe.stripped/foo"
+#     deps = [ ":the_thing_that_makes_foo" ]
 #   }
 template("create_native_executable_dist") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   dist_dir = invoker.dist_dir
   binary = invoker.binary
-  final_deps = []
   template_name = target_name
 
   libraries_list =
       "${target_gen_dir}/${template_name}_library_dependencies.list"
 
   # TODO(gyp)
   #'dependencies': [
   #'<(DEPTH)/build/android/setup.gyp:copy_system_libraries',
   #],
 
+  find_deps_target_name = "${template_name}__find_library_dependencies"
+  copy_target_name = "${template_name}__copy_libraries_and_exe"
+
   stripped_libraries_dir = "$root_build_dir/lib.stripped"
-  final_deps += [ ":${template_name}__find_library_dependencies" ]
-  action("${template_name}__find_library_dependencies") {
+  action(find_deps_target_name) {
+    visibility = [ ":$copy_target_name" ]
+
     script = "//build/android/gyp/write_ordered_libraries.py"
     depfile = "$target_gen_dir/$target_name.d"
     inputs = [
       binary,
       android_readelf,
     ]
     outputs = [
       depfile,
       libraries_list,
     ]
     rebased_binaries = rebase_path([ binary ], root_build_dir)
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--input-libraries=$rebased_binaries",
       "--libraries-dir",
       rebase_path(stripped_libraries_dir, root_build_dir),
       "--output",
       rebase_path(libraries_list, root_build_dir),
       "--readelf",
       rebase_path(android_readelf, root_build_dir),
     ]
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
   }
 
-  final_deps += [ ":${template_name}__copy_libraries_and_exe" ]
-  copy_ex("${template_name}__copy_libraries_and_exe") {
+  copy_ex(copy_target_name) {
+    visibility = [ ":$template_name" ]
+
     clear_dir = true
     inputs = [
       binary,
       libraries_list,
     ]
     dest = dist_dir
     rebased_binaries_list = rebase_path([ binary ], root_build_dir)
     rebased_libraries_list = rebase_path(libraries_list, root_build_dir)
     args = [
       "--files=$rebased_binaries_list",
       "--files=@FileArg($rebased_libraries_list:libraries)",
     ]
+
+    deps = [
+      ":$find_deps_target_name",
+    ]
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
   }
 
-  group(target_name) {
-    deps = final_deps
+  group(template_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+    deps = [
+      ":$copy_target_name",
+    ]
   }
 }
 
 # Compile a protocol buffer to java.
 #
 # This generates java files from protocol buffers and creates an Android library
 # containing the classes.
 #
 # Variables
 #   sources: Paths to .proto files to compile.
@@ skipping 50 matching lines @@
 template("uiautomator_test") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
   assert(target_name != "")
   assert(invoker.deps != [] || true)
   group(target_name) {
   }
 }