Add get_target_outputs function to GN

tools/gn/file_template.h

 // 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.
 
 #ifndef TOOLS_GN_FILE_TEMPLATE_H_
 #define TOOLS_GN_FILE_TEMPLATE_H_
 
 #include <iosfwd>
 
 #include "base/basictypes.h"
 #include "base/containers/stack_container.h"
 #include "tools/gn/err.h"
 #include "tools/gn/value.h"
 
 struct EscapeOptions;
 class ParseNode;
+class SourceFile;
 class Target;
 
 extern const char kSourceExpansion_Help[];
 
 // A FileTemplate object implements source expansion for a given "template"
 // (either outputs or args, depending on the target type).
 //
 // There are two ways you can use this. You can make a template and then
 // apply a source to it to get a list of outputs manually. Or you can do the
 // actual substitution in Ninja, writing the arguments in a rule and using
@@ skipping 27 matching lines @@
     Type type;
 
     // When type_ == LITERAL, this specifies the literal.
     std::string literal;
   };
 
   // Constructs a template from the given value. On error, the err will be
   // set. In this case you should not use this object.
   FileTemplate(const Value& t, Err* err);
   FileTemplate(const std::vector<std::string>& t);
+  FileTemplate(const std::vector<SourceFile>& t);
+
   ~FileTemplate();
 
   // Returns an output template representing the given target's script
   // outputs.
   static FileTemplate GetForTargetOutputs(const Target* target);
 
   // Returns true if the given substitution type is used by this template.
   bool IsTypeUsed(Subrange::Type type) const;
 
   // Returns true if there are any substitutions.
   bool has_substitutions() const { return has_substitutions_; }
 
   // Applies this template to the given list of sources, appending all
   // results to the given dest list. The sources must be a list for the
   // one that takes a value as an input, otherwise the given error will be set.
   void Apply(const Value& sources,
              const ParseNode* origin,
              std::vector<Value>* dest,
              Err* err) const;
+
+  // Low-level version of Apply that handles one source file. The results
+  // will be *appended* to the output.
   void ApplyString(const std::string& input,
                    std::vector<std::string>* output) const;
 
   // Writes a string representing the template with Ninja variables for the
   // substitutions, and the literals escaped for Ninja consumption.
   //
   // For example, if the input is "foo{{source_name_part}}bar" this will write
   // foo${source_name_part}bar. If there are multiple templates (we were
   // constucted with a list of more than one item) then the values will be
   // separated by spaces.
@@ skipping 48 matching lines @@
   // required. This allows us to precompute these types whem applying them
   // to a given source file.
   bool types_required_[Subrange::NUM_TYPES];
 
   // Set when any of the types_required_ is true. Otherwise, everythins is a
   // literal (a common case so we can optimize some code paths).
   bool has_substitutions_;
 };
 
 #endif  // TOOLS_GN_FILE_TEMPLATE_H_