Use the wrapper script in all coverage builds.

Previously the wrapper script would only be used for coverage builds
that required selective instrumentation of specific files. Now it
will also be used for any coverage builds.

Since the script's job is to remove flags from files that shouldn't
have them the default_coverage config now adds to cflags even in a
CQ build.

Bug: 918215
Change-Id: I012c5732d46bf5cff9eaf8f50615739bb781cc29
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1496002
Commit-Queue: Sajjad Mirza <sajjadm@google.com>
Reviewed-by: Dirk Pranke <dpranke@chromium.org>
Reviewed-by: Max Moroz <mmoroz@chromium.org>
Reviewed-by: Yuke Liao <liaoyuke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#638321}

build/config/coverage/BUILD.gn

@@ -25,25 +25,20 @@ config("default_coverage") {
       }
     }
 
-    # Coverage flags are only on by default when instrument all source files.
-    # Otherwise, coverage flags are dynamically passed to the compile command
-    # via the //build/toolchain/clang_code_coverage_wrapper.py script.
-    if (coverage_instrumentation_input_file == "") {
-      cflags = [
-        "-fprofile-instr-generate",
-        "-fcoverage-mapping",
+    cflags = [
+      "-fprofile-instr-generate",
+      "-fcoverage-mapping",
 
-        # Following experimental flags removes unused header functions from the
-        # coverage mapping data embedded in the test binaries, and the reduction
-        # of binary size enables building Chrome's large unit test targets on
-        # MacOS. Please refer to crbug.com/796290 for more details.
-        "-mllvm",
-        "-limited-coverage-experimental=true",
-      ]
+      # Following experimental flags removes unused header functions from the
+      # coverage mapping data embedded in the test binaries, and the reduction
+      # of binary size enables building Chrome's large unit test targets on
+      # MacOS. Please refer to crbug.com/796290 for more details.
+      "-mllvm",
+      "-limited-coverage-experimental=true",
+    ]
 
-      if (!is_win) {
-        cflags += [ "-fno-use-cxa-atexit" ]
-      }
+    if (!is_win) {
+      cflags += [ "-fno-use-cxa-atexit" ]
     }
   }
 }

build/toolchain/gcc_toolchain.gni

@@ -194,25 +194,48 @@ template("gcc_toolchain") {
       compiler_prefix = "${analyzer_wrapper} " + compiler_prefix
     }
 
-    if (defined(toolchain_args.coverage_instrumentation_input_file)) {
-      toolchain_coverage_instrumentation_input_file =
-          toolchain_args.coverage_instrumentation_input_file
+    # A specific toolchain may wish to avoid coverage instrumentation, so we
+    # allow the global "use_clang_coverage" arg to be overridden.
+    if (defined(toolchain_args.use_clang_coverage)) {
+      toolchain_use_clang_coverage = toolchain_args.use_clang_coverage
     } else {
-      toolchain_coverage_instrumentation_input_file =
-          coverage_instrumentation_input_file
+      toolchain_use_clang_coverage = use_clang_coverage
     }
-    _use_clang_coverage_wrapper =
-        toolchain_coverage_instrumentation_input_file != ""
-    if (_use_clang_coverage_wrapper) {
+
+    # For a coverage build, we use the wrapper script globally so that it can
+    # remove coverage cflags from files that should not have them.
+    if (toolchain_use_clang_coverage) {
       assert(!use_clang_static_analyzer,
              "Clang static analyzer wrapper and Clang code coverage wrapper " +
                  "cannot be used together.")
 
+      # "coverage_instrumentation_input_file" is set in args.gn, but it can be
+      # overridden by a toolchain config.
+      if (defined(toolchain_args.coverage_instrumentation_input_file)) {
+        toolchain_coverage_instrumentation_input_file =
+            toolchain_args.coverage_instrumentation_input_file
+      } else {
+        toolchain_coverage_instrumentation_input_file =
+            coverage_instrumentation_input_file
+      }
+
       _coverage_wrapper =
           rebase_path("//build/toolchain/clang_code_coverage_wrapper.py",
-                      root_build_dir) + " --files-to-instrument=" +
-          rebase_path(toolchain_coverage_instrumentation_input_file,
                       root_build_dir)
+
+      # The wrapper needs to know what OS we target because it uses that to
+      # select a list of files that should not be instrumented.
+      _coverage_wrapper = _coverage_wrapper + "--target-os=" + target_os
+
+      # We want to instrument everything if there is no input file set.
+      # If there is a file we need to give it to the wrapper script so it can
+      # instrument only those files.
+      if (toolchain_coverage_instrumentation_input_file != "") {
+        _coverage_wrapper =
+            _coverage_wrapper + " --files-to-instrument=" +
+            rebase_path(toolchain_coverage_instrumentation_input_file,
+                        root_build_dir)
+      }
       compiler_prefix = "${_coverage_wrapper} " + compiler_prefix
     }