Pass input_jars_paths of libs to final proguard step

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")
 import("//build/config/sanitizers/sanitizers.gni")
 
 assert(is_android)
 
 # These identify targets that have .build_config files (except for android_apk,
@@ skipping 319 matching lines @@
       args += [
         "--srcjar",
         rebase_path(invoker.srcjar, root_build_dir),
       ]
     }
     if (defined(invoker.bundled_srcjars)) {
       _rebased_bundled_srcjars =
           rebase_path(invoker.bundled_srcjars, root_build_dir)
       args += [ "--bundled-srcjars=$_rebased_bundled_srcjars" ]
     }
+    if (defined(invoker.input_jars_paths)) {
+      _rebased_input_jars_paths =
+          rebase_path(invoker.input_jars_paths, root_build_dir)
+      print(target_name, _rebased_input_jars_paths)

[agrieve, 2016/08/08 06:33:21]

oops. I'll have to zap this tomorrow.

+      args += [ "--extra-classpath-jars=$_rebased_input_jars_paths" ]
+    }
     if (current_toolchain != default_toolchain) {
       # This has to be a built-time error rather than a GN assert because many
       # packages have a mix of java and non-java targets. For example, the
       # following would fail even though nothing depends on :bar(//baz):
       #
       # shared_library("foo") {
       # }
       #
       # android_library("bar") {
       #   deps = [ ":foo(//baz)" ]
@@ skipping 378 matching lines @@
                                "public_deps",
                                "testonly",
                              ])
       script = "//build/android/gyp/proguard.py"
       if (defined(invoker.proguard_jar_path)) {
         _proguard_jar_path = invoker.proguard_jar_path
       } else {
         _proguard_jar_path = "//third_party/proguard/lib/proguard.jar"
       }
       _output_jar_path = invoker.output_jar_path
-      _input_jars_paths = []
-      if (defined(invoker.input_jars_paths)) {
-        _input_jars_paths += invoker.input_jars_paths
-      }
-      inputs = _input_jars_paths + [ _proguard_jar_path ]
+      inputs = [
+        _proguard_jar_path,
+      ]
       if (defined(invoker.alternative_android_sdk_jar)) {
         inputs += [ invoker.alternative_android_sdk_jar ]
         _rebased_android_sdk_jar =
             rebase_path(invoker.alternative_android_sdk_jar)
       } else {
         inputs += [ android_sdk_jar ]
         _rebased_android_sdk_jar = rebased_android_sdk_jar
       }
       if (defined(invoker.inputs)) {
         inputs += invoker.inputs
@@ skipping 10 matching lines @@
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         "--proguard-path",
         rebase_path(_proguard_jar_path, root_build_dir),
         "--output-path",
         rebase_path(_output_jar_path, root_build_dir),
         "--classpath",
         _rebased_android_sdk_jar,
       ]
-      foreach(c, _input_jars_paths) {
-        args += [ "--classpath=" + rebase_path(c, root_build_dir) ]
-      }
       if (proguard_verbose) {
         args += [ "--verbose" ]
       }
       if (defined(invoker.args)) {
         args += invoker.args
       }
       if (defined(invoker.proguard_jar_path)) {
         # We assume that if we are using a different ProGuard, this new version
         # can handle the 'dangerous' optimizaions.
         args += [ "--enable-dangerous-optimizations" ]
@@ skipping 208 matching lines @@
       }
 
       if (defined(invoker.sources)) {
         args += rebase_path(invoker.sources, root_build_dir)
       }
     }
   }
 
   template("process_java_prebuilt") {
     set_sources_assignment_filter([])
-    forward_variables_from(invoker,
-                           [
-                             "testonly",
-                             "input_jars_paths",
-                           ])
-    assert(!defined(input_jars_paths) || input_jars_paths != [] || true)  # Mark as used
+    forward_variables_from(invoker, [ "testonly" ])
 
     assert(invoker.build_config != "")
     _build_config = invoker.build_config
     _rebased_build_config = rebase_path(_build_config, root_build_dir)
     assert(_rebased_build_config != "" || true)  # Mark used.
 
     _proguard_preprocess =
         defined(invoker.proguard_preprocess) && invoker.proguard_preprocess
     _input_jar_path = invoker.input_jar_path
     _output_jar_path = invoker.output_jar_path
@@ skipping 736 matching lines @@
 
     _build_config_target_name = "${_template_name}__build_config"
     _process_jar_target_name = "${_template_name}__process_jar"
     _ijar_target_name = "${_template_name}__ijar"
     if (_supports_android) {
       _dex_target_name = "${_template_name}__dex"
     }
 
     write_build_config(_build_config_target_name) {
       type = "java_prebuilt"
+      forward_variables_from(invoker, [ "input_jars_paths" ])
       supports_android = _supports_android
       requires_android =
           defined(invoker.requires_android) && invoker.requires_android
 
       if (defined(invoker.deps)) {
         possible_config_deps = _deps
       }
       build_config = _build_config
       jar_path = _jar_path
       if (_supports_android) {
         dex_path = _dex_path
       }
     }
 
     process_java_prebuilt(_process_jar_target_name) {
       forward_variables_from(invoker,
                              [
                                "jar_excluded_patterns",
                                "strip_resource_classes",
-                               "input_jars_paths",
                              ])
-      assert(!defined(input_jars_paths) || input_jars_paths != [] || true)  # Mark as used
 
       visibility = [
         ":$_ijar_target_name",
         ":$_template_name",
       ]
       if (_supports_android) {
         visibility += [ ":$_dex_target_name" ]
       }
 
       if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
@@ skipping 82 matching lines @@
   #     "${target_gen_dir}/${target_name}.jar.
   template("compile_java") {
     set_sources_assignment_filter([])
     forward_variables_from(invoker, [ "testonly" ])
 
     assert(defined(invoker.build_config))
     assert(defined(invoker.jar_path))
 
     _build_config = invoker.build_config
 
-    _input_jars_paths = []
-    if (defined(invoker.input_jars_paths)) {
-      _input_jars_paths += invoker.input_jars_paths
-    }
-
     _chromium_code = false
     if (defined(invoker.chromium_code)) {
       _chromium_code = invoker.chromium_code
     }
 
     _supports_android = true
     if (defined(invoker.supports_android)) {
       _supports_android = invoker.supports_android
     }
 
@@ skipping 126 matching lines @@
           _android_sdk_ijar = invoker.alternative_android_sdk_ijar
         } else {
           deps += [ "//build/android:android_ijar" ]
           _android_sdk_ijar = "$root_out_dir/lib.java/android.interface.jar"
         }
         inputs += [ _android_sdk_ijar ]
         _rebased_android_sdk_ijar =
             rebase_path(_android_sdk_ijar, root_build_dir)
         args += [ "--bootclasspath=$_rebased_android_sdk_ijar" ]
       }
-      foreach(c, _input_jars_paths) {
-        args += [ "--classpath=" + c ]
-      }
       foreach(e, _manifest_entries) {
         args += [ "--manifest-entry=" + e ]
       }
       if (_chromium_code) {
         args += [ "--chromium-code=1" ]
       }
       if (_enable_errorprone) {
         deps += [ "//third_party/errorprone:chromium_errorprone" ]
         args += [
           "--use-errorprone-path",
@@ skipping 171 matching lines @@
 
     # 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
     } else {
       _build_config = _base_path + ".build_config"
       build_config_target_name = "${_template_name}__build_config"
 
       write_build_config(build_config_target_name) {
+        forward_variables_from(invoker, [ "input_jars_paths" ])
         if (defined(invoker.is_java_binary) && invoker.is_java_binary) {
           type = "java_binary"
         } else {
           type = "java_library"
         }
         if (defined(invoker.deps)) {
           possible_config_deps = invoker.deps
         }
         supports_android = _supports_android
         requires_android = _requires_android
@@ skipping 37 matching lines @@
     _final_deps += [ ":$_compile_java_target" ]
     compile_java(_compile_java_target) {
       forward_variables_from(invoker,
                              [
                                "additional_jar_files",
                                "alternative_android_sdk_ijar",
                                "alternative_android_sdk_ijar_dep",
                                "dist_jar_path",
                                "enable_errorprone",
                                "enable_incremental_javac_override",
-                               "input_jars_paths",
                                "jar_excluded_patterns",
                                "manifest_entries",
                                "processors_javac",
                                "processor_args_javac",
                                "proguard_config",
                                "proguard_preprocess",
                                "provider_configurations",
                              ])
       jar_path = _jar_path
       build_config = _build_config
@@ skipping 328 matching lines @@
       outputs = [
         depfile,
         invoker.out_manifest,
       ]
       inputs = [
         invoker.main_manifest,
       ]
     }
   }
 }