🎣 Make Android .build_configs aware of prebuilts and java sources

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 84 matching lines @@
     sources = []
   }
 
   action(target_name) {
     set_sources_assignment_filter([])
     build_config = invoker.build_config
 
     assert(type == "android_apk" || type == "java_library" ||
            type == "android_resources" || type == "deps_dex" ||
            type == "android_assets" || type == "resource_rewriter" ||
-           type == "java_binary" || type == "group")
+           type == "java_binary" || type == "group" || type == "java_prebuilt")
 
     forward_variables_from(invoker,
                            [
                              "deps",
                              "testonly",
                            ])
     if (!defined(deps)) {
       deps = []
     }
 
@@ skipping 36 matching lines @@
     args = [
       "--type",
       type,
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--deps-configs=$_rebased_deps_configs",
       "--build-config",
       rebase_path(build_config, root_build_dir),
     ]
 
-    is_java = type == "java_library" || type == "java_binary"
+    is_java = type == "java_library" || type == "java_binary" ||
+              type == "java_prebuilt"
     is_apk = type == "android_apk"
     is_android_assets = type == "android_assets"
     is_android_resources = type == "android_resources"
     is_deps_dex = type == "deps_dex"
     is_group = type == "group"
 
     supports_android = is_apk || is_android_assets || is_android_resources ||
                        is_deps_dex || is_group ||
                        (is_java && defined(invoker.supports_android) &&
                         invoker.supports_android)
@@ skipping 134 matching lines @@
         _rebased_incremental_apk_path =
             rebase_path(invoker.incremental_apk_path, root_build_dir)
         _rebased_incremental_install_script_path =
             rebase_path(invoker.incremental_install_script_path, root_build_dir)
         args += [ "--apk-path=$_rebased_apk_path" ]
         args += [ "--incremental-apk-path=$_rebased_incremental_apk_path" ]
         args += [ "--incremental-install-script-path=$_rebased_incremental_install_script_path" ]
       }
     }
 
+    if (defined(invoker.java_sources_file)) {
+      args += [
+        "--java-sources-file",
+        rebase_path(invoker.java_sources_file, root_build_dir),
+      ]
+    }
     if (defined(invoker.srcjar)) {
       args += [
         "--srcjar",
         rebase_path(invoker.srcjar, root_build_dir),
       ]
     }
   }
 }
 
 template("copy_ex") {
@@ skipping 705 matching lines @@
                                "data_deps",
                                "visibility",
                              ])
       public_deps = [
         ":$_output_jar_target",
       ]
     }
   }
 
   template("emma_instr") {
-    set_sources_assignment_filter([])
-    forward_variables_from(invoker, [ "testonly" ])
+    action(target_name) {
+      forward_variables_from(invoker,
+                             [
+                               "deps",
+                               "testonly",
+                             ])
 
-    assert(invoker.source_files != [] || true)  # Mark as used
-
-    if (invoker.emma_instrument) {
-      _output_jar_target = "${target_name}__process"
       _coverage_file = "$target_out_dir/${target_name}.em"
       _source_dirs_listing_file = "$target_out_dir/${target_name}_sources.txt"
       _emma_jar = "${android_sdk_root}/tools/lib/emma.jar"
-      _rebased_source_files = rebase_path(invoker.source_files, root_build_dir)
-      action(_output_jar_target) {
-        forward_variables_from(invoker, [ "deps" ])
 
-        script = "//build/android/gyp/emma_instr.py"
-        depfile = "${target_gen_dir}/${target_name}.d"
-        inputs = [
-          _emma_jar,
-          invoker.input_jar_path,
-        ]
-        outputs = [
-          depfile,
-          _coverage_file,
-          _source_dirs_listing_file,
-          invoker.output_jar_path,
-        ]
-        args = [
-          "instrument_jar",
-          "--input-path",
-          rebase_path(invoker.input_jar_path, root_build_dir),
-          "--output-path",
-          rebase_path(invoker.output_jar_path, root_build_dir),
-          "--depfile",
-          rebase_path(depfile, root_build_dir),
-          "--coverage-file",
-          rebase_path(_coverage_file, root_build_dir),
-          "--sources-list-file",
-          rebase_path(_source_dirs_listing_file, root_build_dir),
-          "--source-files=$_rebased_source_files",
-          "--src-root",
-          rebase_path("//", root_build_dir),
-          "--emma-jar",
-          rebase_path(_emma_jar, root_build_dir),
-        ]
+      script = "//build/android/gyp/emma_instr.py"
+      depfile = "${target_gen_dir}/${target_name}.d"
+      inputs = [
+        _emma_jar,
+        invoker.input_jar_path,
+      ]
+      outputs = [
+        depfile,
+        _coverage_file,
+        _source_dirs_listing_file,
+        invoker.output_jar_path,
+      ]
+      args = [
+        "instrument_jar",
+        "--input-path",
+        rebase_path(invoker.input_jar_path, root_build_dir),
+        "--output-path",
+        rebase_path(invoker.output_jar_path, root_build_dir),
+        "--depfile",
+        rebase_path(depfile, root_build_dir),
+        "--coverage-file",
+        rebase_path(_coverage_file, root_build_dir),
+        "--sources-list-file",
+        rebase_path(_source_dirs_listing_file, root_build_dir),
+        "--src-root",
+        rebase_path("//", root_build_dir),
+        "--emma-jar",
+        rebase_path(_emma_jar, root_build_dir),
+      ]
+      if (defined(invoker.java_files)) {
+        _rebased_java_files = rebase_path(invoker.java_files, root_build_dir)
+        args += [ "--source-files=$_rebased_java_files" ]
+      }
+      if (defined(invoker.java_sources_file)) {
+        _rebased_java_sources_file =
+            rebase_path(invoker.java_sources_file, root_build_dir)
+        args += [ "--java-sources-file=$_rebased_java_sources_file" ]
+      }
 
-        if (emma_filter != "") {
-          args += [
-            "--filter-string",
-            emma_filter,
-          ]
-        }
-      }
-    } else {
-      _output_jar_target = "${target_name}__copy_jar"
-      copy(_output_jar_target) {
-        forward_variables_from(invoker, [ "deps" ])
-
-        sources = [
-          invoker.input_jar_path,
-        ]
-        outputs = [
-          invoker.output_jar_path,
+      if (emma_filter != "") {
+        args += [
+          "--filter-string",
+          emma_filter,
         ]
       }
     }
-
-    group(target_name) {
-      forward_variables_from(invoker, [ "visibility" ])
-      public_deps = [
-        ":$_output_jar_target",
-      ]
-    }
   }
 
   # Creates an unsigned .apk.
   #
   # Variables
   #   assets_build_config: Path to android_apk .build_config containing merged
   #       asset information.
   #   deps: Specifies the dependencies of this target.
   #   dex_path: Path to classes.dex file to include (optional).
   #   resource_packaged_apk_path: Path to .ap_ to use.
@@ skipping 557 matching lines @@
     _template_name = target_name
 
     _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_library"
+      type = "java_prebuilt"
       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) {
@@ skipping 89 matching lines @@
   }
 
   # Compiles and jars a set of java files.
   #
   # Outputs:
   #  $jar_path.jar
   #  $jar_path.interface.jar
   #
   # Variables
   #   java_files: List of .java files to compile.
+  #   java_sources_file: Path to file containing list of files to compile.
   #   chromium_code: If true, enable extra warnings.
   #   srcjar_deps: List of srcjar dependencies. The .java files contained in the
   #     dependencies srcjar outputs will be compiled and added to the output jar.
   #   jar_path: Use this to explicitly set the output jar path. Defaults to
   #     "${target_gen_dir}/${target_name}.jar.
   template("compile_java") {
     set_sources_assignment_filter([])
     forward_variables_from(invoker, [ "testonly" ])
 
-    assert(defined(invoker.java_files))
+    assert(defined(invoker.java_files) || defined(invoker.java_sources_file))
     assert(defined(invoker.build_config))
     assert(defined(invoker.jar_path))
 
-    _java_files = invoker.java_files
-    _final_jar_path = invoker.jar_path
-    _javac_jar_path = "$target_gen_dir/$target_name.javac.jar"
-    _process_prebuilt_jar_path =
-        "$target_gen_dir/$target_name.process_prebuilt.jar"
-    _final_ijar_path = get_path_info(_final_jar_path, "dir") + "/" +
-                       get_path_info(_final_jar_path, "name") + ".interface.jar"
-
     _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
@@ skipping 52 matching lines @@
     }
     foreach(dep, _srcjar_deps) {
       _dep_gen_dir = get_label_info(dep, "target_gen_dir")
       _dep_name = get_label_info(dep, "name")
       _java_srcjars += [ "$_dep_gen_dir/$_dep_name.srcjar" ]
     }
 
     # Mark srcjar_deps as used.
     assert(_srcjar_deps == [] || true)
 
+    _javac_target_name = "${target_name}__javac"
+    _process_prebuilt_target_name = "${target_name}__process_prebuilt"
+    _ijar_target_name = "${target_name}__ijar"
+    _final_target_name = target_name
+
+    _final_jar_path = invoker.jar_path
+    _javac_jar_path = "$target_gen_dir/$target_name.javac.jar"
+    _process_prebuilt_jar_path = _final_jar_path
+    _final_ijar_path = get_path_info(_final_jar_path, "dir") + "/" +
+                       get_path_info(_final_jar_path, "name") + ".interface.jar"
+
+    _emma_instrument =
+        defined(invoker.emma_instrument) && invoker.emma_instrument
+    if (_emma_instrument) {
+      _emma_instr_target_name = "${target_name}__emma_instr"
+      _process_prebuilt_jar_path =
+          "$target_gen_dir/$target_name.process_prebuilt.jar"
+    }
+
     _rebased_build_config = rebase_path(_build_config, root_build_dir)
     _rebased_jar_path = rebase_path(_javac_jar_path, root_build_dir)
 
-    _javac_target_name = "${target_name}__javac"
-    _process_prebuilt_target_name = "${target_name}__process_prebuilt"
-    _emma_instr_target_name = "${target_name}__emma_instr"
-    _ijar_target_name = "${target_name}__ijar"
-    _final_target_name = target_name
-
     action(_javac_target_name) {
       script = "//build/android/gyp/javac.py"
       depfile = "$target_gen_dir/$target_name.d"
       deps = _srcjar_deps
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
 
       outputs = [
         depfile,
         _javac_jar_path,
         _javac_jar_path + ".md5.stamp",
       ]
-      sources = _java_files + _java_srcjars
+      sources = _java_srcjars
+      if (defined(invoker.java_files)) {
+        sources += invoker.java_files
+      }
       inputs = [
         _build_config,
       ]
+      if (defined(invoker.java_sources_file)) {
+        inputs += [ invoker.java_sources_file ]
+      }
 
       _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
       _rebased_depfile = rebase_path(depfile, root_build_dir)
       args = [
         "--depfile=$_rebased_depfile",
         "--jar-path=$_rebased_jar_path",
         "--java-srcjars=$_rebased_java_srcjars",
         "--java-srcjars=@FileArg($_rebased_build_config:javac:srcjars)",
       ]
       if (_enable_interface_jars_javac) {
@@ skipping 39 matching lines @@
       }
       foreach(e, _provider_configurations) {
         args += [ "--provider-configuration=" + rebase_path(e, root_build_dir) ]
       }
       foreach(e, _processors) {
         args += [ "--processor=" + e ]
       }
       foreach(e, _processor_args) {
         args += [ "--processor-arg=" + e ]
       }
-      args += rebase_path(_java_files, root_build_dir)
+      if (defined(invoker.java_files)) {
+        args += rebase_path(invoker.java_files, root_build_dir)
+      }
+      if (defined(invoker.java_sources_file)) {
+        args += [ "@" + rebase_path(invoker.java_sources_file, root_build_dir) ]
+      }
     }
 
     process_java_prebuilt(_process_prebuilt_target_name) {
       forward_variables_from(invoker, [ "jar_excluded_patterns" ])
       build_config = _build_config
       input_jar_path = _javac_jar_path
       output_jar_path = _process_prebuilt_jar_path
       if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
         proguard_preprocess = invoker.proguard_preprocess
         proguard_config = invoker.proguard_config
       }
       deps = [
         ":$_javac_target_name",
       ]
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
     }
 
-    emma_instr(_emma_instr_target_name) {
-      visibility = [
-        ":$_ijar_target_name",
-        ":$_final_target_name",
-      ]
+    if (_emma_instrument) {
+      emma_instr(_emma_instr_target_name) {
+        forward_variables_from(invoker,
+                               [
+                                 "java_files",
+                                 "java_sources_file",
+                               ])
 
-      forward_variables_from(invoker, [ "emma_instrument" ])
+        input_jar_path = _process_prebuilt_jar_path
+        output_jar_path = _final_jar_path
 
-      input_jar_path = _process_prebuilt_jar_path
-      output_jar_path = _final_jar_path
-      source_files = _java_files
-
-      deps = [
-        ":$_process_prebuilt_target_name",
-      ]
+        deps = [
+          ":$_process_prebuilt_target_name",
+        ]
+      }
     }
 
     generate_interface_jar(_ijar_target_name) {
       input_jar = _final_jar_path
       output_jar = _final_ijar_path
-      deps = [
-        ":$_emma_instr_target_name",
-      ]
+      if (_emma_instrument) {
+        deps = [
+          ":$_emma_instr_target_name",
+        ]
+      } else {
+        deps = [
+          ":$_process_prebuilt_target_name",
+        ]
+      }
     }
 
     group(_final_target_name) {
       forward_variables_from(invoker, [ "visibility" ])
       public_deps = [
-        ":$_emma_instr_target_name",
         ":$_ijar_target_name",
       ]
+      if (_emma_instrument) {
+        public_deps += [ ":$_emma_instr_target_name" ]
+      } else {
+        public_deps += [ ":$_process_prebuilt_target_name" ]
+      }
     }
   }
 
   template("java_library_impl") {
     set_sources_assignment_filter([])
     forward_variables_from(invoker, [ "testonly" ])
     _accumulated_deps = []
     if (defined(invoker.deps)) {
       _accumulated_deps = invoker.deps
     }
@@ skipping 65 matching lines @@
     assert(_emma_never_instrument || true)  # Mark as used
     _emma_instrument = emma_coverage && !_emma_never_instrument
 
     if (_supports_android) {
       _dex_path = _base_path + ".dex.jar"
       if (defined(invoker.dex_path)) {
         _dex_path = invoker.dex_path
       }
     }
 
+    _java_files = []
+    if (defined(invoker.java_files)) {
+      _java_files += invoker.java_files
+    }
+    if (_java_files != []) {
+      _java_sources_file = "$_base_path.sources"
+      write_file(_java_sources_file, rebase_path(_java_files, root_build_dir))
+    }
+
     # 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) {
         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
         bypass_platform_checks = defined(invoker.bypass_platform_checks) &&
                                  invoker.bypass_platform_checks
 
         build_config = _build_config
         jar_path = _jar_path
         if (_supports_android) {
           dex_path = _dex_path
         }
+        if (_java_files != []) {
+          java_sources_file = _java_sources_file
+        }
       }
       _accumulated_deps += [ ":$build_config_target_name" ]
     }
 
     _srcjar_deps = []
     if (defined(invoker.srcjar_deps)) {
       _srcjar_deps = invoker.srcjar_deps
     }
 
     _srcjars = []
     if (defined(invoker.srcjars)) {
       _srcjars = invoker.srcjars
     }
 
-    _java_files = []
-    if (defined(invoker.java_files)) {
-      _java_files += invoker.java_files
-    }
     assert(_java_files != [] || _srcjar_deps != [] || _srcjars != [])
 
     _compile_java_target = "${_template_name}__compile_java"
     _final_deps += [ ":$_compile_java_target" ]
     compile_java(_compile_java_target) {
       forward_variables_from(invoker,
                              [
                                "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
-      java_files = _java_files
+      if (_java_files != []) {
+        java_sources_file = _java_sources_file
+      } else {
+        java_files = []
+      }
       srcjar_deps = _srcjar_deps
       srcjars = _srcjars
       chromium_code = _chromium_code
       supports_android = _supports_android
       emma_instrument = _emma_instrument
       deps = _accumulated_deps
     }
     _accumulated_deps += [ ":$_compile_java_target" ]
     assert(_accumulated_deps != [])  # Mark used.
 
@@ skipping 310 matching lines @@
       outputs = [
         depfile,
         invoker.out_manifest,
       ]
       inputs = [
         invoker.main_manifest,
       ]
     }
   }
 }