Improve GN handling of directory templates.

tools/gn/action_target_generator.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/action_target_generator.h"
 
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/value.h"
 #include "tools/gn/value_extractors.h"
 #include "tools/gn/variables.h"
 
 namespace {
 
 // Returns true if the list of files looks like it might have a {{ }} pattern
 // in it. Used for error checking.
-bool FileListHasPattern(const Target::FileList& files) {
+bool StringListHasPattern(const std::vector<std::string>& files) {
   for (size_t i = 0; i < files.size(); i++) {
-    if (files[i].value().find("{{") != std::string::npos &&
-        files[i].value().find("}}") != std::string::npos)
+    if (files[i].find("{{") != std::string::npos &&
+        files[i].find("}}") != std::string::npos)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 ActionTargetGenerator::ActionTargetGenerator(
     Target* target,
     Scope* scope,
@@ skipping 67 matching lines @@
     return;
   }
   target_->action_values().set_script(script_file);
 }
 
 void ActionTargetGenerator::FillScriptArgs() {
   const Value* value = scope_->GetValue(variables::kArgs, true);
   if (!value)
     return;
 
-  std::vector<std::string> args;
-  if (!ExtractListOfStringValues(*value, &args, err_))
+  if (!ExtractListOfStringValues(*value, &target_->action_values().args(),
+                                 err_))
     return;
-  target_->action_values().swap_in_args(&args);
 }
 
 void ActionTargetGenerator::FillDepfile() {
   const Value* value = scope_->GetValue(variables::kDepfile, true);
   if (!value)
     return;
   target_->action_values().set_depfile(
       scope_->settings()->build_settings()->build_dir().ResolveRelativeFile(
           value->string_value()));
 }
 
 void ActionTargetGenerator::CheckOutputs() {
-  const Target::FileList& outputs = target_->action_values().outputs();
+  const std::vector<std::string>& outputs = target_->action_values().outputs();
   if (outputs.empty()) {
     *err_ = Err(function_call_, "Action has no outputs.",
         "If you have no outputs, the build system can not tell when your\n"
         "script needs to be run.");
     return;
   }
 
   if (output_type_ == Target::ACTION) {
     // Make sure the outputs for an action have no patterns in them.
-    if (FileListHasPattern(outputs)) {
+    if (StringListHasPattern(outputs)) {
       *err_ = Err(function_call_, "Action has patterns in the output.",
           "An action target should have the outputs completely specified. If\n"
           "you want to provide a mapping from source to output, use an\n"
           "\"action_foreach\" target.");
       return;
     }
   } else if (output_type_ == Target::ACTION_FOREACH) {
     // A foreach target should always have a pattern in the outputs.
-    if (!FileListHasPattern(outputs)) {
+    if (!StringListHasPattern(outputs)) {
       *err_ = Err(function_call_,
           "action_foreach should have a pattern in the output.",
           "An action_foreach target should have a source expansion pattern in\n"
           "it to map source file to unique output file name. Otherwise, the\n"
           "build system can't determine when your script needs to be run.");
       return;
     }
   }
 }