🚙 GN: Add write_runtime_deps variable

tools/gn/target.cc

 // Copyright (c) 2013 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.
 
 #include "tools/gn/target.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 65 matching lines @@
 // to avoid duplicate checking.
 //
 // Checking of object files is optional because it is much slower. This allows
 // us to check targets for normal outputs, and then as a second pass check
 // object files (since we know it will be an error otherwise). This allows
 // us to avoid computing all object file names in the common case.
 bool EnsureFileIsGeneratedByDependency(const Target* target,
                                        const OutputFile& file,
                                        bool check_private_deps,
                                        bool consider_object_files,
+                                       bool check_data_deps,
                                        std::set<const Target*>* seen_targets) {
   if (seen_targets->find(target) != seen_targets->end())
     return false;  // Already checked this one and it's not found.
   seen_targets->insert(target);
 
   // Assume that we have relatively few generated inputs so brute-force
   // searching here is OK. If this becomes a bottleneck, consider storing
   // computed_outputs as a hash set.
   for (const OutputFile& cur : target->computed_outputs()) {
     if (file == cur)
       return true;
   }
 
+  if (file == target->write_runtime_deps_output()) {

[brettw, 2016/03/31 17:35:25]

No {}

[agrieve, 2016/03/31 21:08:32]

Done.

+    return true;
+  }
+
   // Check binary target intermediate files if requested.
   if (consider_object_files && target->IsBinary()) {
     std::vector<OutputFile> source_outputs;
     for (const SourceFile& source : target->sources()) {
       Toolchain::ToolType tool_type;
       if (!target->GetOutputFilesForSource(source, &tool_type, &source_outputs))
         continue;
       if (std::find(source_outputs.begin(), source_outputs.end(), file) !=
           source_outputs.end())
         return true;
     }
   }
 
+  if (check_data_deps) {
+    check_data_deps = false;  // Consider only direct data_deps.
+    for (const auto& pair : target->data_deps()) {
+      if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
+                                            consider_object_files,
+                                            check_data_deps, seen_targets))
+        return true;  // Found a path.
+    }
+  }
+
   // Check all public dependencies (don't do data ones since those are
   // runtime-only).
   for (const auto& pair : target->public_deps()) {
     if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
-                                          consider_object_files, seen_targets))
+                                          consider_object_files,
+                                          check_data_deps, seen_targets))
       return true;  // Found a path.
   }
 
   // Only check private deps if requested.
   if (check_private_deps) {
     for (const auto& pair : target->private_deps()) {
       if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
                                             consider_object_files,
-                                            seen_targets))
+                                            check_data_deps, seen_targets))
         return true;  // Found a path.
     }
     if (target->output_type() == Target::CREATE_BUNDLE) {
       for (const auto& dep : target->bundle_data().bundle_deps()) {
         if (EnsureFileIsGeneratedByDependency(dep, file, false,
                                               consider_object_files,
-                                              seen_targets))
+                                              check_data_deps, seen_targets))
           return true;  // Found a path.
       }
     }
   }
   return false;
 }
 
 // check_this indicates if the given target should be matched against the
 // patterns. It should be set to false for the first call since assert_no_deps
 // shouldn't match the target itself.
@@ skipping 602 matching lines @@
 void Target::CheckSourceGenerated(const SourceFile& source) const {
   if (!IsStringInOutputDir(settings()->build_settings()->build_dir(),
                            source.value()))
     return;  // Not in output dir, this is OK.
 
   // Tell the scheduler about unknown files. This will be noted for later so
   // the list of files written by the GN build itself (often response files)
   // can be filtered out of this list.
   OutputFile out_file(settings()->build_settings(), source);
   std::set<const Target*> seen_targets;
-  if (!EnsureFileIsGeneratedByDependency(this, out_file, true, false,
+  bool check_data_deps = false;
+  bool consider_object_files = false;
+  if (!EnsureFileIsGeneratedByDependency(this, out_file, true,
+                                         consider_object_files, check_data_deps,
                                          &seen_targets)) {
+    seen_targets.clear();
+    // Allow dependency to be through data_deps for files generated by gn.
+    check_data_deps = g_scheduler->IsFileGeneratedByWriteRuntimeDeps(out_file);
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
-    seen_targets.clear();
-    if (!EnsureFileIsGeneratedByDependency(this, out_file, true, true,
-                                           &seen_targets))
+    consider_object_files = !check_data_deps;
+    if (!EnsureFileIsGeneratedByDependency(this, out_file, true,
+                                           consider_object_files,
+                                           check_data_deps, &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }