Improve GN handling of directory templates.

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) {
 }
 
 NinjaActionTargetWriter::~NinjaActionTargetWriter() {
 }
 
 void NinjaActionTargetWriter::Run() {
-  FileTemplate args_template(target_->settings(),
-                             target_->action_values().args());
+  FileTemplate args_template(
+      target_->settings(),
+      target_->action_values().args(),
+      FileTemplate::OUTPUT_RELATIVE,
+      target_->settings()->build_settings()->build_dir());
   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);
@@ skipping 13 matching lines @@
   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 {
     DCHECK(target_->output_type() == Target::ACTION);
 
     // Write a rule that invokes the script once with the outputs as outputs,
     // and the data as inputs.
     out_ << "build";
-    const Target::FileList& outputs = target_->action_values().outputs();
+    const std::vector<std::string>& outputs =
+        target_->action_values().outputs();
     for (size_t i = 0; i < outputs.size(); i++) {
       OutputFile output_path(
-          RemovePrefix(outputs[i].value(),
+          RemovePrefix(outputs[i],
                        settings_->build_settings()->build_dir().value()));
       output_files.push_back(output_path);
       out_ << " ";
       path_output_.WriteFile(out_, output_path);
     }
 
     out_ << ": " << custom_rule_name << implicit_deps << std::endl;
     if (target_->action_values().has_depfile()) {
       out_ << "  depfile = ";
       WriteDepfile(SourceFile());
@@ skipping 59 matching lines @@
   return custom_rule_name;
 }
 
 void NinjaActionTargetWriter::WriteArgsSubstitutions(
     const SourceFile& source,
     const FileTemplate& args_template) {
   EscapeOptions template_escape_options;
   template_escape_options.mode = ESCAPE_NINJA_COMMAND;
 
   args_template.WriteNinjaVariablesForSubstitution(
-      out_, target_->settings(), source, template_escape_options);
+      out_, source, template_escape_options);
 }
 
 void NinjaActionTargetWriter::WriteSourceRules(
     const std::string& custom_rule_name,
     const std::string& implicit_deps,
     const FileTemplate& args_template,
     std::vector<OutputFile>* output_files) {
-  FileTemplate output_template(GetOutputTemplate());
+  FileTemplate output_template = FileTemplate::GetForTargetOutputs(target_);
 
   const Target::FileList& sources = target_->sources();
   for (size_t i = 0; i < sources.size(); i++) {
     out_ << "build";
     WriteOutputFilesForBuildLine(output_template, sources[i], output_files);
 
     out_ << ": " << custom_rule_name << " ";
     path_output_.WriteFile(out_, sources[i]);
     out_ << implicit_deps << std::endl;
 
@@ skipping 38 matching lines @@
   out_ << std::endl;
 }
 
 void NinjaActionTargetWriter::WriteOutputFilesForBuildLine(
     const FileTemplate& output_template,
     const SourceFile& source,
     std::vector<OutputFile>* output_files) {
   std::vector<std::string> output_template_result;
   output_template.Apply(source, &output_template_result);
   for (size_t out_i = 0; out_i < output_template_result.size(); out_i++) {
-    OutputFile output_path(output_template_result[out_i]);
+    // All output files should be in the build directory, so we can rebase
+    // them just by trimming the prefix.
+    OutputFile output_path(
+        RemovePrefix(output_template_result[out_i],
+                     settings_->build_settings()->build_dir().value()));
     output_files->push_back(output_path);
     out_ << " ";
     path_output_.WriteFile(out_, output_path);
   }
 }
 
 void NinjaActionTargetWriter::WriteDepfile(const SourceFile& source) {
   std::vector<std::string> result;
   GetDepfileTemplate().Apply(source, &result);
   path_output_.WriteFile(out_, OutputFile(result[0]));
 }
 
 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(settings_, template_args);
+  return FileTemplate(settings_, template_args, FileTemplate::OUTPUT_ABSOLUTE,
+                      SourceDir());
 }