Optionally compute grit inputs precisely.

tools/grit/grit_rule.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.
 
 # Instantiate grit. This will produce a script target to run grit, and a
 # static library that compiles the .cc files.
 #
 # Parameters
 #
 #   source (required)
 #       Path to .grd file.
 #
+#   source_is_generated (optional, defaults to false)
+#       Declares that the input is generated so that grit_info is not run
+#       on the file when compute_grit_inputs_for_analyze is set (because the
+#       file will not exist at analyze time). For "analyze" to be correct in
+#       this case, the inputs to the grit file must either be listed in the
+#       inputs variable or are listed as inputs to dependencies of this target.
+#
+#   inputs  (optional)
+#       List of additional files, required for grit to process source file.
+#
 #   outputs (required)
 #       List of outputs from grit, relative to the target_gen_dir. Grit will
 #       verify at build time that this list is correct and will fail if there
 #       is a mismatch between the outputs specified by the .grd file and the
 #       outputs list here.
 #
 #       To get this list, you can look in the .grd file for
 #       <output filename="..." and put those filename here. The base directory
 #       of the list in Grit and the output list specified in the GN grit target
 #       are the same (the target_gen_dir) so you can generally copy the names
@@ skipping 29 matching lines @@
 #   depfile_dir (optional)
 #       If set, used to store the depfile and corresponding stamp file.
 #       Defaults to output_dir
 #
 #   use_qualified_include (optional)
 #       If set, output_dir is not added to include_dirs.
 #
 #   configs (optional)
 #       List of additional configs to be applied to the generated target.
 #   deps  (optional)
-#   inputs  (optional)
-#       List of additional files, required for grit to process source file.
 #   visibility  (optional)
 #       Normal meaning.
 #
 # Example
 #
 #   grit("my_resources") {
 #     # Source and outputs are required.
 #     source = "myfile.grd"
 #     outputs = [
 #       "foo_strings.h",
 #       "foo_strings.pak",
 #     ]
 #
 #     grit_flags = [ "-E", "foo=bar" ]  # Optional extra flags.
 #     # You can also put deps here if the grit source depends on generated
 #     # files.
 #   }
 import("//build/config/android/config.gni")
 import("//build/config/chrome_build.gni")
 import("//build/config/crypto.gni")
 import("//build/config/features.gni")
 import("//build/config/ui.gni")
 import("//third_party/closure_compiler/closure_args.gni")
 
 assert(!enable_resource_whitelist_generation || is_android,
        "resource whitelist generation only works on android")
 
+declare_args() {
+  # When set, this will fork out to grit at GN-time to get all inputs
+  # referenced by the .grd file.
+  #
+  # Normal builds don't need this since proper incremental builds are handled
+  # by grit writing out the inputs in .d files at build-time. But for analyze
+  # to work on the bots, it needs to know about all input files at GN-time so
+  # it knows which tests to trigger when something changes. This option will
+  # slow down the GN run.
+  compute_grit_inputs_for_analyze = false
+}
+
 grit_defines = []
 
 # Mac and iOS want Title Case strings.
 use_titlecase_in_grd_files = is_mac || is_ios
 if (use_titlecase_in_grd_files) {
   grit_defines += [
     "-D",
     "use_titlecase",
   ]
 }
@@ skipping 204 matching lines @@
 _strip_resource_files = is_android
 _js_minifier = "//third_party/closure_compiler/js_minify.py"
 
 grit_resource_id_file = "//tools/gritsettings/resource_ids"
 grit_info_script = "//tools/grit/grit_info.py"
 
 template("grit") {
   assert(defined(invoker.source),
          "\"source\" must be defined for the grit template $target_name")
 
-  grit_inputs = [ invoker.source ]
-
   if (defined(invoker.resource_ids)) {
     resource_ids = invoker.resource_ids
   } else {
     resource_ids = grit_resource_id_file
   }
-  if (resource_ids != "") {
-    # The script depends on the ID file. Only add this dependency if the ID
-    # file is specified.
-    grit_inputs += [ resource_ids ]
-  }
 
   if (defined(invoker.output_dir)) {
     output_dir = invoker.output_dir
   } else {
     output_dir = target_gen_dir
   }
 
   if (defined(invoker.output_name)) {
     grit_output_name = invoker.output_name
   } else {
     grit_output_name = target_name
   }
 
   if (defined(invoker.depfile_dir)) {
     depfile_dir = invoker.depfile_dir
   } else {
     depfile_dir = output_dir
   }
 
   # These are all passed as arguments to the script so have to be relative to
   # the build directory.
-  if (resource_ids != "") {
-    resource_ids = rebase_path(resource_ids, root_build_dir)
-  }
   rebased_output_dir = rebase_path(output_dir, root_build_dir)
   source_path = rebase_path(invoker.source, root_build_dir)
 
+  # Compute flags.
   grit_flags = []
   if (enable_resource_whitelist_generation) {
     grit_flags += [ "-h" ]
     if (is_win) {
       grit_flags += [ "#define {textual_id} __pragma(message(\"whitelisted_resource_{numeric_id}\")) {numeric_id}" ]
     } else {
       grit_flags += [ "#define {textual_id} _Pragma(\"whitelisted_resource_{numeric_id}\") {numeric_id}" ]
     }
   }
   if (defined(invoker.grit_flags)) {
     grit_flags += invoker.grit_flags
   }
+  if (resource_ids != "") {
+    grit_flags += [
+      "-f",
+      rebase_path(resource_ids, root_build_dir),
+    ]
+  }
+
+  if (defined(invoker.source_is_generated)) {
+    source_is_generated = invoker.source_is_generated
+  } else {
+    source_is_generated = false
+  }
 
   assert_files_flags = []
 
   # We want to make sure the declared outputs actually match what Grit is
   # writing. We write the list to a file (some of the output lists are long
   # enough to not fit on a Windows command line) and ask Grit to verify those
   # are the actual outputs at runtime.
   asserted_list_file =
       "$target_out_dir/${grit_output_name}_expected_outputs.txt"
   write_file(asserted_list_file,
@@ skipping 24 matching lines @@
         "-Wunknown-pragmas",
         "-Wno-error=unknown-pragmas",
       ]
     }
     visibility = target_visibility
   }
 
   grit_custom_target = target_name + "_grit"
   action(grit_custom_target) {
     script = "//tools/grit/grit.py"
-    inputs = grit_inputs
+
+    inputs = [
+      invoker.source,
+    ]
+    if (resource_ids != "") {
+      # The script depends on the ID file. Only add this dependency if the ID
+      # file is specified.
+      inputs += [ resource_ids ]
+    }
 
     depfile = "$depfile_dir/${grit_output_name}_stamp.d"
     outputs = [ "${depfile}.stamp" ] + grit_outputs
 
     args = [
-      "-i",
-      source_path,
-      "build",
-    ]
-    if (resource_ids != "") {
-      args += [
-        "-f",
-        resource_ids,
-      ]
-    }
-    args += [
-              "-o",
-              rebased_output_dir,
-              "--depdir",
-              ".",
-              "--depfile",
-              rebase_path(depfile, root_build_dir),
-              "--write-only-new=1",
-              "--depend-on-stamp",
-            ] + grit_defines
+             "-i",
+             source_path,
+             "build",
+             "-o",
+             rebased_output_dir,
+             "--depdir",
+             ".",
+             "--depfile",
+             rebase_path(depfile, root_build_dir),
+             "--write-only-new=1",
+             "--depend-on-stamp",
+           ] + grit_defines
 
     # Add extra defines with -D flags.
+    define_args = []
     if (defined(invoker.defines)) {
       foreach(i, invoker.defines) {
-        args += [
+        define_args += [
           "-D",
           i,
         ]
       }
     }
 
-    args += grit_flags + assert_files_flags
+    args += define_args + grit_flags + assert_files_flags
 
     if (_strip_resource_files) {
       js_minifier_command = rebase_path(_js_minifier)
       js_minifier_command = "$js_minifier_command --closure_args"
       foreach(closure_arg,
               common_closure_args + minifying_closure_args +
                   default_disabled_closure_args) {
         js_minifier_command = "$js_minifier_command $closure_arg"
       }
       args += [
         "--js-minifier",
         js_minifier_command,
       ]
       inputs += [ _js_minifier ]
     }
 
+    # Must be after the args are computed since they are re-used.
+    # See the comments for the two variables used in this condition for
+    # why this works this way.
+    if (compute_grit_inputs_for_analyze && !source_is_generated) {
+      grit_info_script = "//tools/grit/grit_info.py"
+      grit_info_args = [
+                         "--inputs",
+                         source_path,
+                       ] + grit_flags + grit_defines
+
+      # Only call exec_script when the user has explicitly opted into greater
+      # precision at the expense of performance.
+      rel_inputs = exec_script(grit_info_script,
+                               grit_info_args,
+                               "list lines",
+                               [ grit_info_script ])
+      inputs += rebase_path(rel_inputs, ".", root_build_dir)
+    } else {
+      assert(source_is_generated || !source_is_generated)  # Prevent error.
+    }
+
     if (defined(invoker.visibility)) {
       # This needs to include both what the invoker specified (since they
       # probably include generated headers from this target), as well as the
       # generated source set (since there's no guarantee that the visibility
       # specified by the invoker includes our target).
       #
       # Only define visibility at all if the invoker specified it. Otherwise,
       # we want to keep the public "no visibility specified" default.
       visibility = target_visibility + invoker.visibility
     }
@@ skipping 32 matching lines @@
     if (defined(invoker.configs)) {
       configs += invoker.configs
     }
 
     if (defined(invoker.visibility)) {
       visibility = invoker.visibility
     }
     output_name = grit_output_name
   }
 }