Update from https://crrev.com/333737

build/config/android/internal_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("//build/config/android/config.gni")
 
 assert(is_android)
 
 rebased_android_sdk = rebase_path(android_sdk, root_build_dir)
 rebased_android_sdk_root = rebase_path(android_sdk_root, root_build_dir)
 rebased_android_sdk_build_tools =
     rebase_path(android_sdk_build_tools, root_build_dir)
 
 android_sdk_jar = "$android_sdk/android.jar"
 rebased_android_sdk_jar = rebase_path(android_sdk_jar, root_build_dir)
+android_aapt_path = "$rebased_android_sdk_build_tools/aapt"
 
 template("android_lint") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   jar_path = invoker.jar_path
   android_manifest = invoker.android_manifest
   java_files = invoker.java_files
@@ skipping 26 matching lines @@
       "--product-dir=.",
       "--jar-path",
       rebase_path(jar_path, root_build_dir),
       "--processed-config-path",
       rebase_path(config_path, root_build_dir),
       "--result-path",
       rebase_path(result_path, root_build_dir),
       "--java-files=$rebased_java_files",
       "--enable",
     ]
+
+    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
+    }
   }
 }
 
 template("findbugs") {
   jar_path = invoker.jar_path
 
   build_config = invoker.build_config
 
   action(target_name) {
     script = "//build/android/findbugs_diff.py"
@@ skipping 104 matching lines @@
       rebase_path(depfile, root_build_dir),
       "--inputs=$rebase_inputs",
       "--output=$rebase_output",
     ]
     if (defined(invoker.base_dir)) {
       args += [
         "--base-dir",
         rebase_path(invoker.base_dir, root_build_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 (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
   }
 }
 
 # Write the target's .build_config file. This is a json file that contains a
 # dictionary of information about how to build this target (things that
 # require knowledge about this target's dependencies and cannot be calculated
 # at gn-time). There is a special syntax to add a value in that dictionary to
 # an action/action_foreachs args:
 #   --python-arg=@FileArg($rebased_build_config_path:key0:key1)
 # At runtime, such an arg will be replaced by the value in the build_config.
 # See build/android/gyp/write_build_config.py and
 # build/android/gyp/util/build_utils.py:ExpandFileArgs
 template("write_build_config") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   assert(defined(invoker.type))
   assert(defined(invoker.build_config))
 
   type = invoker.type
   build_config = invoker.build_config
 
   assert(type == "android_apk" || type == "java_library" ||
          type == "android_resources" || type == "deps_dex")
 
   action(target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+
     script = "//build/android/gyp/write_build_config.py"
     depfile = "$target_gen_dir/$target_name.d"
     inputs = []
 
     deps = []
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
 
     possible_deps_configs = []
@@ skipping 138 matching lines @@
   _output_jar_path = invoker.output_jar_path
   _jar_toc_path = _output_jar_path + ".TOC"
 
   assert(invoker.build_config != "")
 
   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
     _proguard_jar_path = "$android_sdk_root/tools/proguard/lib/proguard.jar"
     _proguard_config_path = invoker.proguard_config
     _build_config = invoker.build_config
     _rebased_build_config = rebase_path(_build_config, root_build_dir)
-    action("${target_name}__proguard_process") {
+    _output_jar_target = "${target_name}__proguard_process"
+    action(_output_jar_target) {
       script = "//build/android/gyp/proguard.py"
       inputs = [
         android_sdk_jar,
         _proguard_jar_path,
         _build_config,
         _input_jar_path,
         _proguard_config_path,
       ]
       depfile = "${target_gen_dir}/${target_name}.d"
       outputs = [
         depfile,
         _output_jar_path,
       ]
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         "--proguard-path",
         rebase_path(_proguard_jar_path, root_build_dir),
         "--input-path",
         rebase_path(_input_jar_path, root_build_dir),
         "--output-path",
         rebase_path(_output_jar_path, root_build_dir),
         "--proguard-config",
         rebase_path(_proguard_config_path, root_build_dir),
         "--classpath",
         rebased_android_sdk_jar,
         "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
       ]
+
+      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
+      }
     }
   } else {
-    copy("${target_name}__copy_jar") {
+    _output_jar_target = "${target_name}__copy_jar"
+    copy(_output_jar_target) {
       sources = [
         _input_jar_path,
       ]
       outputs = [
         _output_jar_path,
       ]
+
+      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
+      }
     }
   }
 
   action("${target_name}__jar_toc") {
     script = "//build/android/gyp/jar_toc.py"
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
       _jar_toc_path,
       _jar_toc_path + ".md5.stamp",
     ]
     inputs = [
       _output_jar_path,
     ]
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--jar-path",
       rebase_path(_output_jar_path, root_build_dir),
       "--toc-path",
       rebase_path(_jar_toc_path, root_build_dir),
     ]
+    public_deps = [
+      ":$_output_jar_target",
+    ]
   }
 
   group(target_name) {
-    deps = [
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+    public_deps = [
       ":${target_name}__jar_toc",
+      ":$_output_jar_target",
     ]
   }
 }
 
+template("finalize_apk") {
+  action(target_name) {
+    script = "//build/android/gyp/finalize_apk.py"
+    depfile = "$target_gen_dir/$target_name.d"
+
+    if (defined(invoker.testonly)) {
+      testonly = invoker.testonly
+    }
+
+    sources = [
+      invoker.input_apk_path,
+    ]
+    inputs = [
+      invoker.keystore_path,
+    ]
+    outputs = [
+      depfile,
+      invoker.output_apk_path,
+    ]
+
+    args = [
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
+      "--zipalign-path",
+      rebase_path(zipalign_path, root_build_dir),
+      "--unsigned-apk-path",
+      rebase_path(invoker.input_apk_path, root_build_dir),
+      "--final-apk-path",
+      rebase_path(invoker.output_apk_path, root_build_dir),
+      "--key-path",
+      rebase_path(invoker.keystore_path, root_build_dir),
+      "--key-name",
+      invoker.keystore_name,
+      "--key-passwd",
+      invoker.keystore_password,
+    ]
+    if (defined(invoker.rezip_apk) && invoker.rezip_apk) {
+      _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
+      inputs += [ _rezip_jar_path ]
+      args += [
+        "--load-library-from-zip=1",
+        "--rezip-apk-jar-path",
+        rebase_path(_rezip_jar_path, root_build_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
+    }
+  }
+}
+
 # Packages resources, assets, dex, and native libraries into an apk. Signs and
 # zipaligns the apk.
 template("create_apk") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   _android_manifest = invoker.android_manifest
   _base_path = invoker.base_path
   _final_apk_path = invoker.apk_path
-  _resources_zip = invoker.resources_zip
-  _dex_path = invoker.dex_path
-  _keystore_path = invoker.keystore_path
-  _keystore_name = invoker.keystore_name
-  _keystore_password = invoker.keystore_password
+
+  if (defined(invoker.resources_zip)) {
+    _resources_zip = invoker.resources_zip
+  }
+  if (defined(invoker.dex_path)) {
+    _dex_path = invoker.dex_path
+  }
   _load_library_from_apk = invoker.load_library_from_apk
 
-  _deps = []
+  _package_deps = []
   if (defined(invoker.deps)) {
-    _deps = invoker.deps
+    _package_deps = invoker.deps
   }
 
   _native_libs_dir = "//build/android/empty/res"
   if (defined(invoker.native_libs_dir)) {
     _native_libs_dir = invoker.native_libs_dir
   }
 
-  _asset_location = "//build/android/empty/res"
   if (defined(invoker.asset_location)) {
     _asset_location = invoker.asset_location
   }
 
   _version_code = invoker.version_code
   _version_name = invoker.version_name
 
   _base_apk_path = _base_path + ".apk_intermediates"
 
   _resource_packaged_apk_path = _base_apk_path + ".ap_"
   _packaged_apk_path = _base_apk_path + ".unfinished.apk"
   _shared_resources =
       defined(invoker.shared_resources) && invoker.shared_resources
 
   _configuration_name = "Release"
   if (is_debug) {
     _configuration_name = "Debug"
   }
 
-  action("${target_name}__package_resources") {
-    deps = _deps
+  _create_density_splits =
+      defined(invoker.create_density_splits) && invoker.create_density_splits
+  if (_create_density_splits) {
+    _split_densities = [
+      "hdpi",
+      "xhdpi",
+      "xxhdpi",
+      "tvdpi",
+    ]
+  }
+
+  _package_resources_target_name = "${target_name}__package_resources"
+  action(_package_resources_target_name) {
+    deps = _package_deps
 
     script = "//build/android/gyp/package_resources.py"
     depfile = "${target_gen_dir}/${target_name}.d"
     inputs = [
       _android_manifest,
-      _resources_zip,
     ]
+    if (defined(_resources_zip)) {
+      inputs += [ _resources_zip ]
+    }
     outputs = [
       depfile,
       _resource_packaged_apk_path,
     ]
 
-    _rebased_resources_zips = [ rebase_path(_resources_zip, root_build_dir) ]
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--android-sdk",
       rebased_android_sdk,
-      "--android-sdk-tools",
-      rebased_android_sdk_build_tools,
+      "--aapt-path",
+      android_aapt_path,
       "--configuration-name=$_configuration_name",
       "--android-manifest",
       rebase_path(_android_manifest, root_build_dir),
       "--version-code",
       _version_code,
       "--version-name",
       _version_name,
-      "--asset-dir",
-      rebase_path(_asset_location, root_build_dir),
-      "--resource-zips=$_rebased_resources_zips",
       "--apk-path",
       rebase_path(_resource_packaged_apk_path, root_build_dir),
     ]
 
+    if (defined(_asset_location)) {
+      args += [
+        "--asset-dir",
+        rebase_path(_asset_location, root_build_dir),
+      ]
+    }
+    if (defined(_resources_zip)) {
+      args += [
+        "--resource-zips",
+        rebase_path(_resources_zip, root_build_dir),
+      ]
+    }
     if (_shared_resources) {
       args += [ "--shared-resources" ]
     }
+    if (_create_density_splits) {
+      args += [ "--create-density-splits" ]
+      foreach(_density, _split_densities) {
+        outputs += [ "${_resource_packaged_apk_path}-${_density}" ]
+      }
+    }
   }
 
-  action("${target_name}__package") {
+  package_target = "${target_name}__package"
+  action(package_target) {
     script = "//build/android/gyp/ant.py"
     _ant_script = "//build/android/ant/apk-package.xml"
 
+    deps = [
+      ":${_package_resources_target_name}",
+    ]
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
     depfile = "$target_gen_dir/$target_name.d"
 
     inputs = [
-      _dex_path,
       _resource_packaged_apk_path,
       _ant_script,
     ]
+    if (defined(_dex_path)) {
+      inputs += [ _dex_path ]
+    }
 
     outputs = [
       depfile,
       _packaged_apk_path,
     ]
 
     _rebased_emma_jar = ""
     _rebased_resource_packaged_apk_path =
         rebase_path(_resource_packaged_apk_path, root_build_dir)
     _rebased_packaged_apk_path = rebase_path(_packaged_apk_path, root_build_dir)
     _rebased_native_libs_dir = rebase_path(_native_libs_dir, root_build_dir)
-    _rebased_dex_path = rebase_path(_dex_path, root_build_dir)
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--",
       "-quiet",
       "-DANDROID_SDK_ROOT=$rebased_android_sdk_root",
       "-DANDROID_SDK_TOOLS=$rebased_android_sdk_build_tools",
       "-DRESOURCE_PACKAGED_APK_NAME=$_rebased_resource_packaged_apk_path",
       "-DCONFIGURATION_NAME=$_configuration_name",
       "-DNATIVE_LIBS_DIR=$_rebased_native_libs_dir",
       "-DOUT_DIR=",
       "-DUNSIGNED_APK_PATH=$_rebased_packaged_apk_path",
       "-DEMMA_INSTRUMENT=0",
       "-DEMMA_DEVICE_JAR=$_rebased_emma_jar",
-      "-DDEX_FILE_PATH=$_rebased_dex_path",
       "-Dbasedir=.",
       "-buildfile",
       rebase_path(_ant_script, root_build_dir),
     ]
+    if (defined(_dex_path)) {
+      _rebased_dex_path = rebase_path(_dex_path, root_build_dir)
+      args += [
+        "-DDEX_FILE_PATH=$_rebased_dex_path",
+        "-DHAS_CODE=true",
+      ]
+    } else {
+      args += [ "-DHAS_CODE=false" ]
+    }
   }
 
-  action("${target_name}__finalize") {
-    script = "//build/android/gyp/finalize_apk.py"
-    depfile = "$target_gen_dir/$target_name.d"
+  _finalize_apk_rule_name = "${target_name}__finalize"
+  finalize_apk(_finalize_apk_rule_name) {
+    input_apk_path = _packaged_apk_path
+    output_apk_path = _final_apk_path
+    keystore_path = invoker.keystore_path
+    keystore_name = invoker.keystore_name
+    keystore_password = invoker.keystore_password
+    rezip_apk = _load_library_from_apk
 
-    sources = [
-      _packaged_apk_path,
+    public_deps = [
+      # Generator of the _packaged_apk_path this target takes as input.
+      ":$package_target",
     ]
-    inputs = [
-      _keystore_path,
-    ]
-    outputs = [
-      depfile,
-      _final_apk_path,
-    ]
+  }
 
-    args = [
-      "--depfile",
-      rebase_path(depfile, root_build_dir),
-      "--zipalign-path",
-      rebase_path(zipalign_path, root_build_dir),
-      "--unsigned-apk-path",
-      rebase_path(_packaged_apk_path, root_build_dir),
-      "--final-apk-path",
-      rebase_path(_final_apk_path, root_build_dir),
-      "--key-path",
-      rebase_path(_keystore_path, root_build_dir),
-      "--key-name",
-      _keystore_name,
-      "--key-passwd",
-      _keystore_password,
-    ]
-    if (_load_library_from_apk) {
-      _rezip_jar_path = "$root_build_dir/lib.java/rezip_apk.jar"
-      inputs += [ _rezip_jar_path ]
-      args += [
-        "--load-library-from-zip-file=1",
-        "--rezip-apk-jar-path",
-        rebase_path(_rezip_jar_path, root_build_dir),
-      ]
+  _final_deps = [ ":${_finalize_apk_rule_name}" ]
+
+  if (_create_density_splits) {
+    foreach(_density, _split_densities) {
+      _finalize_split_rule_name = "${target_name}__finalize_${_density}_split"
+      finalize_apk(_finalize_split_rule_name) {
+        input_apk_path = "${_resource_packaged_apk_path}-${_density}"
+        _output_paths = process_file_template(
+                [ _final_apk_path ],
+                "{{source_dir}}/{{source_name_part}}-${_density}.apk")
+        output_apk_path = _output_paths[0]
+        keystore_path = invoker.keystore_path
+        keystore_name = invoker.keystore_name
+        keystore_password = invoker.keystore_password
+      }
+      _final_deps += [ ":${_finalize_split_rule_name}" ]
     }
   }
 
   group(target_name) {
-    deps = [
-      ":${target_name}__finalize",
-    ]
+    public_deps = _final_deps
   }
 }
 
 template("java_prebuilt_impl") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
   _supports_android =
       defined(invoker.supports_android) && invoker.supports_android
 
   assert(defined(invoker.jar_path))
   _base_path = "${target_gen_dir}/$target_name"
   _jar_path = _base_path + ".jar"
   _build_config = _base_path + ".build_config"
 
   if (_supports_android) {
     _dex_path = _base_path + ".dex.jar"
   }
 
-  _final_deps = []
   _template_name = target_name
 
-  _final_deps += [ ":${_template_name}__build_config" ]
-  write_build_config("${_template_name}__build_config") {
+  build_config_target_name = "${_template_name}__build_config"
+  process_jar_target_name = "${_template_name}__process_jar"
+  if (_supports_android) {
+    dex_target_name = "${_template_name}__dex"
+  }
+
+  write_build_config(build_config_target_name) {
     type = "java_library"
     supports_android = _supports_android
     requires_android =
         defined(invoker.requires_android) && invoker.requires_android
 
     deps = []
     if (defined(invoker.deps)) {
       deps += invoker.deps
     }
     build_config = _build_config
     jar_path = _jar_path
     if (_supports_android) {
       dex_path = _dex_path
     }
   }
 
-  _final_deps += [ ":${_template_name}__process_jar" ]
-  process_java_prebuilt("${_template_name}__process_jar") {
+  process_java_prebuilt(process_jar_target_name) {
+    visibility = [ ":$_template_name" ]
+    if (_supports_android) {
+      visibility += [ ":$dex_target_name" ]
+    }
+
     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
       proguard_preprocess = true
       proguard_config = invoker.proguard_config
     }
 
     build_config = _build_config
     input_jar_path = invoker.jar_path
     output_jar_path = _jar_path
+
+    deps = [
+      ":$build_config_target_name",
+    ]
   }
 
   if (_supports_android) {
-    _final_deps += [ ":${_template_name}__dex" ]
-    dex("${_template_name}__dex") {
+    dex(dex_target_name) {
       sources = [
         _jar_path,
       ]
       output = _dex_path
+      deps = [
+        ":$process_jar_target_name",
+      ]
     }
   }
 
   group(target_name) {
-    deps = _final_deps
+    deps = [
+      ":$process_jar_target_name",
+    ]
+    if (_supports_android) {
+      deps += [ ":$dex_target_name" ]
+    }
   }
 }
 
 # Compiles and jars a set of java files.
 #
 # Outputs:
 #  $jar_path.jar
 #  $jar_path.jar.TOC
 #
 # Variables
@@ skipping 54 matching lines @@
   assert(_srcjar_deps == [] || true)
 
   _system_jars = []
   if (defined(invoker.android) && invoker.android) {
     _system_jars += [ android_sdk_jar ]
   }
 
   _rebased_build_config = rebase_path(_build_config, root_build_dir)
   _rebased_jar_path = rebase_path(_intermediate_jar_path, root_build_dir)
 
-  _template_name = target_name
-  _final_deps = [ ":${_template_name}__javac" ]
-  action("${_template_name}__javac") {
+  javac_target_name = "${target_name}__javac"
+  finish_target_name = "${target_name}__finish"
+  final_target_name = target_name
+
+  action(javac_target_name) {
     script = "//build/android/gyp/javac.py"
     depfile = "$target_gen_dir/$target_name.d"
-    deps = []
+    deps = _srcjar_deps
+    if (defined(invoker.deps)) {
+      deps += invoker.deps
+    }
+
     outputs = [
       depfile,
       _intermediate_jar_path,
       _intermediate_jar_path + ".md5.stamp",
     ]
     sources = _java_files + _java_srcjars
     inputs = _system_jars + [ _build_config ]
 
     _rebased_system_jars = rebase_path(_system_jars, root_build_dir)
     _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
@@ skipping 10 matching lines @@
     foreach(e, _manifest_entries) {
       args += [ "--manifest-entry=" + e ]
     }
     if (_chromium_code) {
       args += [ "--chromium-code=1" ]
     }
 
     args += rebase_path(_java_files, root_build_dir)
   }
 
-  _final_deps += [ ":${_template_name}__finish" ]
-  process_java_prebuilt("${_template_name}__finish") {
+  process_java_prebuilt(finish_target_name) {
+    visibility = [ ":$final_target_name" ]
+
     build_config = _build_config
     input_jar_path = _intermediate_jar_path
     output_jar_path = _final_jar_path
     if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
       proguard_preprocess = invoker.proguard_preprocess
       proguard_config = invoker.proguard_config
     }
+    deps = [
+      ":$javac_target_name",
+    ]
   }
 
-  group(target_name) {
-    deps = _final_deps
+  group(final_target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+    public_deps = [
+      ":$finish_target_name",
+    ]
   }
 }
 
 template("java_library_impl") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   assert(
@@ skipping 17 matching lines @@
   _requires_android =
       defined(invoker.requires_android) && invoker.requires_android
 
   if (_supports_android) {
     _dex_path = _base_path + ".dex.jar"
     if (defined(invoker.dex_path)) {
       _dex_path = invoker.dex_path
     }
   }
 
+  # Define build_config_deps which will be a list of targets required to
+  # build the _build_config.
   if (defined(invoker.override_build_config)) {
     _build_config = invoker.override_build_config
+
+    # When a custom build config file is specified, we need to use the deps
+    # supplied by the invoker any time we reference the build config file.
+    assert(defined(invoker.deps),
+           "If you specify a build config file for " +
+               "java_library_impl($target_name), you should " +
+               "also specify the target that made it in the deps")
+    build_config_deps = invoker.deps
   } else {
     _build_config = _base_path + ".build_config"
-    _final_deps += [ ":${_template_name}__build_config" ]
-    write_build_config("${_template_name}__build_config") {
+    build_config_target_name = "${_template_name}__build_config"
+    build_config_deps = [ ":$build_config_target_name" ]
+
+    write_build_config(build_config_target_name) {
       type = "java_library"
       supports_android = _supports_android
       requires_android = _requires_android
       bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
                                invoker.bypass_platform_checks
 
       deps = []
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
@@ skipping 38 matching lines @@
             [
               "--pattern",
               "*.java",
               rebase_path(invoker.DEPRECATED_java_in_dir, root_build_dir),
             ],
             "list lines")
     _java_files = rebase_path(_java_files_build_rel, ".", root_build_dir)
   }
   assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
 
-  _final_deps += [ ":${_template_name}__compile_java" ]
-  compile_java("${_template_name}__compile_java") {
+  _compile_java_target = "${_template_name}__compile_java"
+  _final_deps += [ ":$_compile_java_target" ]
+  compile_java(_compile_java_target) {
     jar_path = _jar_path
     build_config = _build_config
     java_files = _java_files
     srcjar_deps = _srcjar_deps
     srcjars = _srcjars
     chromium_code = _chromium_code
     android = _requires_android
 
     if (defined(invoker.jar_excluded_patterns)) {
       jar_excluded_patterns = invoker.jar_excluded_patterns
     }
     if (defined(invoker.proguard_preprocess)) {
       proguard_preprocess = invoker.proguard_preprocess
     }
     if (defined(invoker.proguard_config)) {
       proguard_config = invoker.proguard_config
     }
     if (defined(invoker.dist_jar_path)) {
       dist_jar_path = invoker.dist_jar_path
     }
     if (defined(invoker.manifest_entries)) {
       manifest_entries = invoker.manifest_entries
     }
+
+    deps = build_config_deps
   }
 
   if (defined(invoker.main_class)) {
     _final_deps += [ ":${_template_name}__binary_script" ]
     action("${_template_name}__binary_script") {
       script = "//build/android/gyp/create_java_binary_script.py"
       depfile = "$target_gen_dir/$target_name.d"
       java_script = "$root_build_dir/bin/$_template_name"
       inputs = [
         _build_config,
       ]
       outputs = [
         depfile,
         java_script,
       ]
       _rebased_build_config = rebase_path(_build_config, root_build_dir)
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         "--output",
         rebase_path(java_script, root_build_dir),
         "--classpath=@FileArg($_rebased_build_config:java:full_classpath)",
         "--jar-path",
         rebase_path(_jar_path, root_build_dir),
         "--main-class",
         invoker.main_class,
       ]
+
+      deps = build_config_deps
     }
   }
 
   if (_supports_android) {
     if (defined(invoker.chromium_code) && invoker.chromium_code) {
       _android_manifest = "//build/android/AndroidManifest.xml"
       if (defined(invoker.android_manifest)) {
         _android_manifest = invoker.android_manifest
       }
 
       _final_datadeps += [ ":${_template_name}__lint" ]
       android_lint("${_template_name}__lint") {
         android_manifest = _android_manifest
         jar_path = _jar_path
         java_files = _java_files
+        deps = [
+          ":$_compile_java_target",
+        ]
+        if (defined(invoker.deps)) {
+          deps += invoker.deps
+        }
       }
 
       if (run_findbugs) {
         _final_datadeps += [ ":${_template_name}__findbugs" ]
         findbugs("${_template_name}__findbugs") {
           build_config = _build_config
           jar_path = _jar_path
+          deps = build_config_deps
         }
       }
     }
 
     _final_deps += [ ":${_template_name}__dex" ]
     dex("${_template_name}__dex") {
       sources = [
         _jar_path,
       ]
       output = _dex_path
+      deps = [
+        ":$_compile_java_target",
+      ]
     }
   }
 
   group(target_name) {
     if (defined(invoker.visibility)) {
       visibility = invoker.visibility
     }
-    deps = _final_deps
-    datadeps = _final_datadeps
+    public_deps = _final_deps
+    data_deps = _final_datadeps
   }
 }
 
 # Runs process_resources.py
 template("process_resources") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   zip_path = invoker.zip_path
   srcjar_path = invoker.srcjar_path
   r_text_path = invoker.r_text_path
   build_config = invoker.build_config
   resource_dirs = invoker.resource_dirs
   android_manifest = invoker.android_manifest
 
   non_constant_id = true
   if (defined(invoker.generate_constant_ids) && invoker.generate_constant_ids) {
     non_constant_id = false
   }
 
   action(target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+
     script = "//build/android/gyp/process_resources.py"
 
     depfile = "$target_gen_dir/$target_name.d"
     outputs = [
       depfile,
       zip_path,
       srcjar_path,
       r_text_path,
     ]
 
     sources_build_rel = exec_script("//build/android/gyp/find.py",
                                     rebase_path(resource_dirs, root_build_dir),
                                     "list lines")
     sources = rebase_path(sources_build_rel, ".", root_build_dir)
 
     inputs = [
       build_config,
       android_manifest,
     ]
 
     rebase_resource_dirs = rebase_path(resource_dirs, root_build_dir)
     rebase_build_config = rebase_path(build_config, root_build_dir)
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--android-sdk",
       rebase_path(android_sdk, root_build_dir),
-      "--android-sdk-tools",
-      rebase_path(android_sdk_build_tools, root_build_dir),
+      "--aapt-path",
+      android_aapt_path,
       "--android-manifest",
       rebase_path(android_manifest, root_build_dir),
       "--resource-dirs=$rebase_resource_dirs",
       "--srcjar-out",
       rebase_path(srcjar_path, root_build_dir),
       "--resource-zip-out",
       rebase_path(zip_path, root_build_dir),
       "--r-text-out",
       rebase_path(r_text_path, root_build_dir),
       "--dependencies-res-zips=@FileArg($rebase_build_config:resources:dependency_zips)",
       "--extra-res-packages=@FileArg($rebase_build_config:resources:extra_package_names)",
       "--extra-r-text-files=@FileArg($rebase_build_config:resources:extra_r_text_files)",
     ]
 
     if (non_constant_id) {
       args += [ "--non-constant-id" ]
     }
 
     if (defined(invoker.custom_package)) {
       args += [
         "--custom-package",
         invoker.custom_package,
       ]
     }
 
-    if (defined(invoker.v14_verify_only) && invoker.v14_verify_only) {
-      args += [ "--v14-verify-only" ]
+    if (defined(invoker.v14_skip) && invoker.v14_skip) {
+      args += [ "--v14-skip" ]
     }
 
     if (defined(invoker.shared_resources) && invoker.shared_resources) {
       args += [ "--shared-resources" ]
     }
 
     if (defined(invoker.include_all_resources) &&
         invoker.include_all_resources) {
       args += [ "--include-all-resources" ]
     }
 
     if (defined(invoker.all_resources_zip_path)) {
       all_resources_zip = invoker.all_resources_zip_path
       outputs += [ all_resources_zip ]
       args += [
         "--all-resources-zip-out",
         rebase_path(all_resources_zip, root_build_dir),
       ]
     }
 
     if (defined(invoker.args)) {
       args += invoker.args
     }
+    if (defined(invoker.deps)) {
+      deps = invoker.deps
+    }
   }
 }
 
 template("copy_ex") {
   set_sources_assignment_filter([])
   if (defined(invoker.testonly)) {
     testonly = invoker.testonly
   }
 
   action(target_name) {
+    if (defined(invoker.visibility)) {
+      visibility = invoker.visibility
+    }
+
     script = "//build/android/gyp/copy_ex.py"
 
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
 
     sources = []
     if (defined(invoker.sources)) {
       sources += invoker.sources
     }
@@ skipping 24 matching lines @@
     if (defined(invoker.args)) {
       args += invoker.args
     }
   }
 }
 
 # Produces a single .dex.jar out of a set of Java dependencies.
 template("deps_dex") {
   set_sources_assignment_filter([])
   build_config = "$target_gen_dir/${target_name}.build_config"
-  write_build_config("${target_name}__build_config") {
+  build_config_target_name = "${target_name}__build_config"
+
+  write_build_config(build_config_target_name) {
     type = "deps_dex"
     deps = invoker.deps
 
     build_config = build_config
     dex_path = invoker.dex_path
   }
 
   rebased_build_config = rebase_path(build_config, root_build_dir)
   dex(target_name) {
     inputs = [
       build_config,
     ]
     output = invoker.dex_path
     dex_arg_key = "${rebased_build_config}:final_dex:dependency_dex_files"
     args = [ "--inputs=@FileArg($dex_arg_key)" ]
     if (defined(invoker.excluded_jars)) {
       excluded_jars = rebase_path(invoker.excluded_jars, root_build_dir)
       args += [ "--excluded-paths=${excluded_jars}" ]
     }
+    deps = [
+      ":$build_config_target_name",
+    ]
   }
 }
 
 # Creates an AndroidManifest.xml for an APK split.
 template("generate_split_manifest") {
   assert(defined(invoker.main_manifest))
   assert(defined(invoker.out_manifest))
   assert(defined(invoker.split_name))
 
   action(target_name) {
@@ skipping 32 matching lines @@
     script = "//build/android/gyp/generate_split_manifest.py"
     outputs = [
       depfile,
       invoker.out_manifest,
     ]
     inputs = [
       invoker.main_manifest,
     ]
   }
 }
+
+# Generates a script in the output bin directory which runs the test
+# target using the test runner script in build/android/test_runner.py.
+template("test_runner_script") {
+  testonly = true
+  _test_name = invoker.test_name
+  _test_type = invoker.test_type
+
+  action(target_name) {
+    script = "//build/android/gyp/create_test_runner_script.py"
+    depfile = "$target_gen_dir/$target_name.d"
+
+    test_runner_args = [
+      _test_type,
+      "--output-directory",
+      rebase_path(root_build_dir, root_build_dir),
+    ]
+    if (_test_type == "gtest") {
+      assert(defined(invoker.test_suite))
+      test_runner_args += [
+        "--suite",
+        invoker.test_suite,
+      ]
+    } else if (_test_type == "instrumentation") {
+      assert(defined(invoker.test_apk))
+      test_runner_args += [
+        "--test-apk",
+        invoker.test_apk,
+      ]
+    } else {
+      assert(false, "Invalid test type: $_test_type.")
+    }
+
+    if (defined(invoker.isolate_file)) {
+      test_runner_args += [
+        "--isolate-file-path",
+        rebase_path(invoker.isolate_file, root_build_dir),
+      ]
+    }
+
+    generated_script = "$root_build_dir/bin/run_${_test_name}"
+    outputs = [
+      depfile,
+      generated_script,
+    ]
+    args = [
+      "--depfile",
+      rebase_path(depfile, root_build_dir),
+      "--script-output-path",
+      rebase_path(generated_script, root_build_dir),
+    ]
+    args += test_runner_args
+  }
+}