Support deps for actions in GN.

tools/gn/ninja_action_target_writer.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/ninja_action_target_writer.h"
 
 #include "base/strings/string_util.h"
 #include "tools/gn/err.h"
 #include "tools/gn/file_template.h"
 #include "tools/gn/string_utils.h"
 #include "tools/gn/target.h"
 
 NinjaActionTargetWriter::NinjaActionTargetWriter(const Target* target,
                                                  const Toolchain* toolchain,
                                                  std::ostream& out)
     : NinjaTargetWriter(target, toolchain, out),
       path_output_no_escaping_(
           target->settings()->build_settings()->build_dir(),
           ESCAPE_NONE, false) {
 }
 
 NinjaActionTargetWriter::~NinjaActionTargetWriter() {
 }
 
 void NinjaActionTargetWriter::Run() {
   FileTemplate args_template(target_->action_values().args());
   std::string custom_rule_name = WriteRuleDefinition(args_template);
+
+  // Collect our deps to pass as "extra hard dependencies" for input deps. This
+  // will force all of the action's dependencies to be completed before the
+  // action is run. Usually, if an action has a dependency, it will be
+  // operating on the result of that previous step, so we need to be sure to
+  // serialize these.
+  std::vector<const Target*> extra_hard_deps;
+  for (size_t i = 0; i < target_->deps().size(); i++)
+    extra_hard_deps.push_back(target_->deps()[i].ptr);
+
   // For ACTIONs this is a bit inefficient since it creates an input dep
   // stamp file even though we're only going to use it once. It would save a
   // build step to skip this and write the order-only deps directly on the
   // build rule. This should probably be handled by WriteInputDepsStampAndGetDep
   // automatically if we supply a count of sources (so it can optimize based on
   // how many times things would be duplicated).
-  std::string implicit_deps = WriteInputDepsStampAndGetDep();
+  std::string implicit_deps = WriteInputDepsStampAndGetDep(extra_hard_deps);
   out_ << std::endl;
 
   // Collects all output files for writing below.
   std::vector<OutputFile> output_files;
 
   if (target_->output_type() == Target::ACTION_FOREACH) {
     // Write separate build lines for each input source file.
     WriteSourceRules(custom_rule_name, implicit_deps, args_template,
                      &output_files);
   } else {
@@ skipping 127 matching lines @@
   }
 }
 
 void NinjaActionTargetWriter::WriteStamp(
     const std::vector<OutputFile>& output_files) {
   out_ << "build ";
   path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));
   out_ << ": "
        << helper_.GetRulePrefix(target_->settings())
        << "stamp";
+
+  // The action stamp depends on all output files from running the action.
   for (size_t i = 0; i < output_files.size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_, output_files[i]);
   }
+
+  // It also depends on all datadeps. These are needed at runtime and should
+  // be compiled when the action is, but don't need to be done before we run
+  // the action.
+  for (size_t i = 0; i < target_->datadeps().size(); i++) {
+    out_ << " ";
+    path_output_.WriteFile(out_,
+        helper_.GetTargetOutputFile(target_->datadeps()[i].ptr));
+  }
+
   out_ << std::endl;
 }
 
 void NinjaActionTargetWriter::WriteOutputFilesForBuildLine(
     const FileTemplate& output_template,
     const SourceFile& source,
     std::vector<OutputFile>* output_files) {
   // If there is a depfile specified we need to list it as the first output as
   // that is what ninja will expect the depfile to refer to itself as.
   if (target_->action_values().has_depfile()) {
@@ skipping 17 matching lines @@
 }
 
 FileTemplate NinjaActionTargetWriter::GetDepfileTemplate() const {
   std::vector<std::string> template_args;
   std::string depfile_relative_to_build_dir =
       RemovePrefix(target_->action_values().depfile().value(),
                    settings_->build_settings()->build_dir().value());
   template_args.push_back(depfile_relative_to_build_dir);
   return FileTemplate(template_args);
 }