Port EMMA Java code coverage build rules to GN

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/zip.gni")
 import("//third_party/ijar/ijar.gni")
 
 assert(is_android)
 
@@ skipping 451 matching lines @@
     }
   }
 }
 
 template("process_java_prebuilt") {
   set_sources_assignment_filter([])
   forward_variables_from(invoker, [ "testonly" ])
 
   _input_jar_path = invoker.input_jar_path
   _output_jar_path = invoker.output_jar_path
-  _output_ijar_path = get_path_info(_output_jar_path, "dir") + "/" +
-                      get_path_info(_output_jar_path, "name") + ".interface.jar"
 
   assert(invoker.build_config != "")
 
   if (defined(invoker.proguard_preprocess) && invoker.proguard_preprocess) {
     _build_config = invoker.build_config
     _rebased_build_config = rebase_path(_build_config, root_build_dir)
     _proguard_config_path = invoker.proguard_config
     _output_jar_target = "${target_name}__proguard_process"
     proguard(_output_jar_target) {
       forward_variables_from(invoker,
@@ skipping 28 matching lines @@
                              ])
       sources = [
         _input_jar_path,
       ]
       outputs = [
         _output_jar_path,
       ]
     }
   }
 
-  generate_interface_jar("${target_name}__ijar") {
-    input_jar = _output_jar_path
-    output_jar = _output_ijar_path
-    deps = [
-      ":$_output_jar_target",
-    ]
-  }
-
   group(target_name) {
     forward_variables_from(invoker, [ "visibility" ])
     public_deps = [
-      ":${target_name}__ijar",
       ":$_output_jar_target",
     ]
   }
+}
+
+template("emma_instr") {
+  set_sources_assignment_filter([])
+  forward_variables_from(invoker, [ "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),
+        "--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,
+      ]
+    }
+  }
+
+  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 59 matching lines @@
       args += [ "--android-abi=$android_app_abi" ]
     }
     if (defined(invoker.native_libs_dir)) {
       _rebased_native_libs_dir =
           rebase_path(invoker.native_libs_dir, root_build_dir)
       args += [ "--native-libs-dir=$_rebased_native_libs_dir/$android_app_abi" ]
     }
     if (_native_lib_placeholders != []) {
       args += [ "--native-lib-placeholders=$_native_lib_placeholders" ]
     }
+
+    if (defined(invoker.emma_instrument) && invoker.emma_instrument) {
+      _emma_device_jar = "$android_sdk_root/tools/lib/emma_device.jar"
+      _rebased_emma_device_jar = rebase_path(_emma_device_jar, root_build_dir)
+      args += [ "--emma-device-jar=$_rebased_emma_device_jar" ]
+    }
   }
 }
 
 # Signs & zipaligns an apk.
 #
 # Variables
 #   input_apk_path: Path of the .apk to be finalized.
 #   output_apk_path: Output path for the generated .apk.
 #   keystore_path: Path to keystore to use for signing.
 #   keystore_name: Key alias to use.
@@ skipping 248 matching lines @@
         _incremental_deps + [ ":$_generate_incremental_manifest_target_name" ]
     android_manifest = _incremental_android_manifest
     resource_packaged_apk_path = _incremental_resource_packaged_apk_path
   }
 
   package_target = "${target_name}__package"
   package_apk(package_target) {
     forward_variables_from(invoker,
                            [
                              "assets_build_config",
+                             "emma_instrument",
                              "native_lib_placeholders",
                              "native_libs_dir",
                            ])
     deps = _deps + [ ":${_package_resources_target_name}" ]
 
     if (defined(_dex_path)) {
       dex_path = _dex_path
     }
 
     output_apk_path = _packaged_apk_path
     resource_packaged_apk_path = _resource_packaged_apk_path
   }
 
   _incremental_package_target = "${target_name}_incremental__package"
   package_apk(_incremental_package_target) {
-    forward_variables_from(invoker, [ "assets_build_config" ])
+    forward_variables_from(invoker,
+                           [
+                             "assets_build_config",
+                             "emma_instrument",
+                           ])
     _dex_target = "//build/android/incremental_install:bootstrap_java__dex"
     deps = _incremental_deps + [
              ":${_incremental_package_resources_target_name}",
              _dex_target,
            ]
 
     if (defined(_dex_path)) {
       dex_path =
           get_label_info(_dex_target, "target_gen_dir") + "/bootstrap.dex"
     }
@@ skipping 86 matching lines @@
   _supports_android =
       defined(invoker.supports_android) && invoker.supports_android
 
   assert(defined(invoker.jar_path))
   _base_path = "${target_gen_dir}/$target_name"
 
   # Jar files can be needed at runtime (by Robolectric tests or java binaries),
   # so do not put them under gen/.
   _target_dir_name = get_label_info(":$target_name", "dir")
   _jar_path = "$root_out_dir/lib.java$_target_dir_name/$target_name.jar"
+  _ijar_path =
+      "$root_out_dir/lib.java$_target_dir_name/$target_name.interface.jar"
   _build_config = _base_path + ".build_config"
 
   if (_supports_android) {
     _dex_path = _base_path + ".dex.jar"
   }
   _deps = []
   if (defined(invoker.deps)) {
     _deps = invoker.deps
   }
   _jar_deps = []
   if (defined(invoker.jar_dep)) {
     _jar_deps = [ invoker.jar_dep ]
   }
 
   _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"
     supports_android = _supports_android
     requires_android =
         defined(invoker.requires_android) && invoker.requires_android
 
     deps = _deps
     build_config = _build_config
     jar_path = _jar_path
     if (_supports_android) {
       dex_path = _dex_path
     }
   }
 
   process_java_prebuilt(_process_jar_target_name) {
-    visibility = [ ":$_template_name" ]
+    visibility = [
+      ":$_ijar_target_name",
+      ":$_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" ] + _deps + _jar_deps
   }
 
+  generate_interface_jar(_ijar_target_name) {
+    input_jar = _jar_path
+    output_jar = _ijar_path
+    deps = [
+      ":$_process_jar_target_name",
+    ]
+  }
+
   if (_supports_android) {
     dex(_dex_target_name) {
       sources = [
         _jar_path,
       ]
       output = _dex_path
       deps = [ ":$_process_jar_target_name" ] + _deps + _jar_deps
     }
   }
 
@@ skipping 11 matching lines @@
       script_name = _template_name
       deps = [
         ":$_build_config_target_name",
       ]
     }
   }
 
   group(target_name) {
     forward_variables_from(invoker, [ "data_deps" ])
     deps = [
+      ":$_ijar_target_name",
       ":$_process_jar_target_name",
     ]
     if (_supports_android) {
       deps += [ ":$_dex_target_name" ]
     }
     data_deps = []
     if (defined(invoker.data_deps)) {
       data_deps += invoker.data_deps
     }
     if (defined(invoker.main_class)) {
@@ skipping 20 matching lines @@
 template("compile_java") {
   set_sources_assignment_filter([])
   forward_variables_from(invoker, [ "testonly" ])
 
   assert(defined(invoker.java_files))
   assert(defined(invoker.build_config))
   assert(defined(invoker.jar_path))
 
   _java_files = invoker.java_files
   _final_jar_path = invoker.jar_path
-  _intermediate_jar_path = "$target_gen_dir/$target_name.initial.jar"
+  _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
 
   _jar_excluded_patterns = []
   if (defined(invoker.jar_excluded_patterns)) {
     _jar_excluded_patterns += invoker.jar_excluded_patterns
   }
 
   _chromium_code = false
   if (defined(invoker.chromium_code)) {
@@ skipping 34 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)
 
   _rebased_build_config = rebase_path(_build_config, root_build_dir)
-  _rebased_jar_path = rebase_path(_intermediate_jar_path, root_build_dir)
+  _rebased_jar_path = rebase_path(_javac_jar_path, root_build_dir)
 
   _javac_target_name = "${target_name}__javac"
-  _finish_target_name = "${target_name}__finish"
+  _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,
-      _intermediate_jar_path,
-      _intermediate_jar_path + ".md5.stamp",
+      _javac_jar_path,
+      _javac_jar_path + ".md5.stamp",
     ]
     sources = _java_files + _java_srcjars
     inputs = [
       _build_config,
     ]
 
     _rebased_java_srcjars = rebase_path(_java_srcjars, root_build_dir)
     _rebased_depfile = rebase_path(depfile, root_build_dir)
     args = [
       "--depfile=$_rebased_depfile",
       "--use-ijars",
       "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
       "--jar-path=$_rebased_jar_path",
       "--java-srcjars=$_rebased_java_srcjars",
       "--java-srcjars=@FileArg($_rebased_build_config:javac:srcjars)",
       "--jar-excluded-classes=$_jar_excluded_patterns",
     ]
     if (_enable_incremental_javac) {
       args += [ "--incremental" ]
       deps += [ "//third_party/jmake" ]
-      outputs += [ "${_intermediate_jar_path}.pdb" ]
+      outputs += [ "${_javac_jar_path}.pdb" ]
     }
     if (_supports_android) {
       if (defined(invoker.alternative_android_sdk_ijar)) {
         deps += [ invoker.alternative_android_sdk_ijar_dep ]
         _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(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",
         "bin/chromium_errorprone",
       ]
     }
     args += rebase_path(_java_files, root_build_dir)
   }
 
-  process_java_prebuilt(_finish_target_name) {
-    visibility = [ ":$_final_target_name" ]
-
+  process_java_prebuilt(_process_prebuilt_target_name) {
     build_config = _build_config
-    input_jar_path = _intermediate_jar_path
-    output_jar_path = _final_jar_path
+    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",
     ]
   }
 
+  emma_instr(_emma_instr_target_name) {
+    visibility = [
+      ":$_ijar_target_name",
+      ":$_final_target_name",
+    ]
+
+    forward_variables_from(invoker, [ "emma_instrument" ])
+
+    input_jar_path = _process_prebuilt_jar_path
+    output_jar_path = _final_jar_path
+    source_files = _java_files
+
+    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",
+    ]
+  }
+
   group(_final_target_name) {
     forward_variables_from(invoker, [ "visibility" ])
     public_deps = [
-      ":$_finish_target_name",
+      ":$_emma_instr_target_name",
+      ":$_ijar_target_name",
     ]
   }
 }
 
 template("java_library_impl") {
   set_sources_assignment_filter([])
   forward_variables_from(invoker, [ "testonly" ])
 
   assert(
       defined(invoker.java_files) || defined(invoker.DEPRECATED_java_in_dir) ||
@@ skipping 21 matching lines @@
       defined(invoker.requires_android) && invoker.requires_android
   assert(_requires_android || true)  # Mark as used.
   _android_manifest = "//build/android/AndroidManifest.xml"
   if (defined(invoker.android_manifest)) {
     _android_manifest = invoker.android_manifest
   }
   assert(_android_manifest != "")  # Mark as used.
   _run_findbugs = defined(invoker.run_findbugs) && invoker.run_findbugs
   assert(_run_findbugs || true)  # Mark as used.
 
+  _chromium_code = true
+  if (defined(invoker.chromium_code)) {
+    _chromium_code = invoker.chromium_code
+  }
+
+  _emma_never_instrument = !_chromium_code
+  if (defined(invoker.emma_never_instrument)) {
+    _emma_never_instrument = invoker.emma_never_instrument
+  }
+  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
     }
   }
 
   # Define build_config_deps which will be a list of targets required to
   # build the _build_config.
   if (defined(invoker.override_build_config)) {
@@ skipping 20 matching lines @@
                                invoker.bypass_platform_checks
 
       build_config = _build_config
       jar_path = _jar_path
       if (_supports_android) {
         dex_path = _dex_path
       }
     }
   }
 
-  _chromium_code = true
-  if (defined(invoker.chromium_code)) {
-    _chromium_code = invoker.chromium_code
-  }
-
   _srcjar_deps = []
   if (defined(invoker.srcjar_deps)) {
     _srcjar_deps = invoker.srcjar_deps
   }
 
   _srcjars = []
   if (defined(invoker.srcjars)) {
     _srcjars = invoker.srcjars
   }
 
@@ skipping 38 matching lines @@
                              "proguard_config",
                              "proguard_preprocess",
                            ])
     jar_path = _jar_path
     build_config = _build_config
     java_files = _java_files
     srcjar_deps = _srcjar_deps
     srcjars = _srcjars
     chromium_code = _chromium_code
     supports_android = _supports_android
+    emma_instrument = _emma_instrument
     deps = build_config_deps
   }
 
   if (defined(invoker.main_class)) {
     _final_datadeps += [ ":${_template_name}__java_binary_script" ]
     java_binary_script("${_template_name}__java_binary_script") {
       forward_variables_from(invoker,
                              [
                                "bootclasspath",
                                "main_class",
@@ skipping 32 matching lines @@
         }
       }
     }
 
     _final_deps += [ ":${_template_name}__dex" ]
     dex("${_template_name}__dex") {
       sources = [
         _jar_path,
       ]
       output = _dex_path
+      no_locals = _emma_instrument
       deps = [
         ":$_compile_java_target",
       ]
     }
   }
 
   group(target_name) {
     forward_variables_from(invoker, [ "visibility" ])
     public_deps = _final_deps
     data_deps = _final_datadeps
@@ skipping 308 matching lines @@
     ]
     args = [
       "--depfile",
       rebase_path(depfile, root_build_dir),
       "--script-output-path",
       rebase_path(generated_script, root_build_dir),
     ]
     args += test_runner_args
   }
 }