Support script response files 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/deps_iterator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/settings.h"
@@ skipping 87 matching lines @@
   // there will be only one invocation so we can use a simple name.
   std::string target_label = target_->label().GetUserVisibleName(true);
   std::string custom_rule_name(target_label);
   base::ReplaceChars(custom_rule_name, ":/()", "_", &custom_rule_name);
   custom_rule_name.append("_rule");
 
   const SubstitutionList& args = target_->action_values().args();
   EscapeOptions args_escape_options;
   args_escape_options.mode = ESCAPE_NINJA_COMMAND;
 
-  if (settings_->IsWin()) {
-    // Send through gyp-win-tool and use a response file.
+  out_ << "rule " << custom_rule_name << std::endl;
+
+  if (target_->action_values().uses_rsp_file()) {
+    // Needs a response file. The unique_name part is for action_foreach so
+    // each invocation of the rule gets a different response file. This isn't
+    // strictly necessary for regular one-shot actions, but it's easier to
+    // just always define unique_name.
     std::string rspfile = custom_rule_name;
     if (!target_->sources().empty())
       rspfile += ".$unique_name";
     rspfile += ".rsp";
-
-    out_ << "rule " << custom_rule_name << std::endl;
-    out_ << "  command = ";
-    path_output_.WriteFile(out_, settings_->build_settings()->python_path());
-    // TODO(brettw) this hardcodes "environment.x86" which is something that
-    // the Chrome Windows toolchain writes. We should have a way to invoke
-    // python without requiring this gyp_win_tool thing.
-    out_ << " gyp-win-tool action-wrapper environment.x86 " << rspfile
-         << std::endl;
-    out_ << "  description = ACTION " << target_label << std::endl;
-    out_ << "  restat = 1" << std::endl;
     out_ << "  rspfile = " << rspfile << std::endl;
 
-    // The build command goes in the rsp file.
-    out_ << "  rspfile_content = ";
-    path_output_.WriteFile(out_, settings_->build_settings()->python_path());
-    out_ << " ";
-    path_output_.WriteFile(out_, target_->action_values().script());
-    for (const auto& arg : args.list()) {
+    // Response file contents.
+    out_ << "  rspfile_content =";
+    for (const auto& arg :
+         target_->action_values().rsp_file_contents().list()) {
       out_ << " ";
       SubstitutionWriter::WriteWithNinjaVariables(
           arg, args_escape_options, out_);
     }
     out_ << std::endl;
-  } else {
-    // Posix can execute Python directly.
-    out_ << "rule " << custom_rule_name << std::endl;
-    out_ << "  command = ";
-    path_output_.WriteFile(out_, settings_->build_settings()->python_path());
+  }
+
+  out_ << "  command = ";
+  path_output_.WriteFile(out_, settings_->build_settings()->python_path());
+  out_ << " ";
+  path_output_.WriteFile(out_, target_->action_values().script());
+  for (const auto& arg : args.list()) {
     out_ << " ";
-    path_output_.WriteFile(out_, target_->action_values().script());
-    for (const auto& arg : args.list()) {
-      out_ << " ";
-      SubstitutionWriter::WriteWithNinjaVariables(
-          arg, args_escape_options, out_);
-    }
-    out_ << std::endl;
-    out_ << "  description = ACTION " << target_label << std::endl;
-    out_ << "  restat = 1" << std::endl;
+    SubstitutionWriter::WriteWithNinjaVariables(
+        arg, args_escape_options, out_);
   }
+  out_ << std::endl;
+  out_ << "  description = ACTION " << target_label << std::endl;
+  out_ << "  restat = 1" << std::endl;
 
   return custom_rule_name;
 }
 
 void NinjaActionTargetWriter::WriteSourceRules(
     const std::string& custom_rule_name,
     const OutputFile& input_dep,
     std::vector<OutputFile>* output_files) {
   EscapeOptions args_escape_options;
   args_escape_options.mode = ESCAPE_NINJA_COMMAND;
   // We're writing the substitution values, these should not be quoted since
   // they will get pasted into the real command line.
   args_escape_options.inhibit_quoting = true;
 
-  const std::vector<SubstitutionType>& args_substitutions_used =
-      target_->action_values().args().required_types();
-
   const Target::FileList& sources = target_->sources();
   for (size_t i = 0; i < sources.size(); i++) {
     out_ << "build";
     WriteOutputFilesForBuildLine(sources[i], output_files);
 
     out_ << ": " << custom_rule_name << " ";
     path_output_.WriteFile(out_, sources[i]);
     if (!input_dep.value().empty()) {
       // Using "|" for the dependencies forces all implicit dependencies to be
       // fully up-to-date before running the action, and will re-run this
       // action if any input dependencies change. This is important because
       // this action may consume the outputs of previous steps.
       out_ << " | ";
       path_output_.WriteFile(out_, input_dep);
     }
     out_ << std::endl;
 
-    // Windows needs a unique ID for the response file.
-    if (target_->settings()->IsWin())
+    // Response files require a unique name be defined.
+    if (target_->action_values().uses_rsp_file())
       out_ << "  unique_name = " << i << std::endl;
 
+    // The required types is the union of the args and response file. This
+    // might theoretically duplicate a definition if the same substitution is
+    // used in both the args and the reponse file. However, this should be
+    // very unusual (normally the substitutions will go in one place or the
+    // other) and the redundant assignment won't bother Ninja.
     SubstitutionWriter::WriteNinjaVariablesForSource(
-        settings_, sources[i], args_substitutions_used,
+        settings_, sources[i],
+        target_->action_values().args().required_types(),
+        args_escape_options, out_);
+    SubstitutionWriter::WriteNinjaVariablesForSource(
+        settings_, sources[i],
+        target_->action_values().rsp_file_contents().required_types(),
         args_escape_options, out_);
 
     if (target_->action_values().has_depfile()) {
       out_ << "  depfile = ";
       WriteDepfile(sources[i]);
       out_ << std::endl;
     }
   }
 }
 
 void NinjaActionTargetWriter::WriteOutputFilesForBuildLine(
     const SourceFile& source,
     std::vector<OutputFile>* output_files) {
   size_t first_output_index = output_files->size();
 
   SubstitutionWriter::ApplyListToSourceAsOutputFile(
       settings_, target_->action_values().outputs(), source, output_files);
 
   for (size_t i = first_output_index; i < output_files->size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_, (*output_files)[i]);
   }
 }
 
 void NinjaActionTargetWriter::WriteDepfile(const SourceFile& source) {
   path_output_.WriteFile(out_,
       SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
           settings_, target_->action_values().depfile(), source));
 }