Add testonly flag to GN

tools/gn/target.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_TARGET_H_
 #define TOOLS_GN_TARGET_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 35 matching lines @@
 
   Target(const Settings* settings, const Label& label);
   virtual ~Target();
 
   // Returns a string naming the output type.
   static const char* GetStringForOutputType(OutputType type);
 
   // Item overrides.
   virtual Target* AsTarget() OVERRIDE;
   virtual const Target* AsTarget() const OVERRIDE;
-  virtual void OnResolved() OVERRIDE;
+  virtual bool OnResolved(Err* err) OVERRIDE;
 
   OutputType output_type() const { return output_type_; }
   void set_output_type(OutputType t) { output_type_ = t; }
 
   bool IsLinkable() const;
 
   // Will be the empty string to use the target label as the output name.
   // See GetComputedOutputName().
   const std::string& output_name() const { return output_name_; }
   void set_output_name(const std::string& name) { output_name_ = name; }
@@ skipping 17 matching lines @@
   // Set to true when all sources are public. This is the default. In this case
   // the public headers list should be empty.
   bool all_headers_public() const { return all_headers_public_; }
   void set_all_headers_public(bool p) { all_headers_public_ = p; }
 
   // When all_headers_public is false, this is the list of public headers. It
   // could be empty which would mean no headers are public.
   const FileList& public_headers() const { return public_headers_; }
   FileList& public_headers() { return public_headers_; }
 
+  bool testonly() const { return testonly_; }
+  void set_testonly(bool value) { testonly_ = value; }
+
   // Compile-time extra dependencies.
   const FileList& inputs() const { return inputs_; }
   FileList& inputs() { return inputs_; }
 
   // Runtime dependencies.
   const FileList& data() const { return data_; }
   FileList& data() { return data_; }
 
   // Returns true if targets depending on this one should have an order
   // dependency.
@@ skipping 87 matching lines @@
   // that. This is a cache of the files to prevent every target that depends on
   // a given library from recomputing the same pattern.
   const OutputFile& link_output_file() const {
     return link_output_file_;
   }
   const OutputFile& dependency_output_file() const {
     return dependency_output_file_;
   }
 
  private:
+  void ExpandGroups();
+
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
   void PullDependentTargetInfo();
 
   // These each pull specific things from dependencies to this one when all
   // deps have been resolved.
   void PullForwardedDependentConfigs();
   void PullRecursiveHardDeps();
 
   // Fills the link and dependency output files when a target is resolved.
   void FillOutputFiles();
 
+  // Validates the given thing when a target is resolved.
+  bool CheckVisibility(Err* err) const;
+  bool CheckTestonly(Err* err) const;
+
   OutputType output_type_;
   std::string output_name_;
   std::string output_extension_;
 
   FileList sources_;
   bool all_headers_public_;
   FileList public_headers_;
+  bool testonly_;
   FileList inputs_;
   FileList data_;
 
   bool hard_dep_;
 
   // Note that if there are any groups in the deps, once the target is resolved
   // these vectors will list *both* the groups as well as the groups' deps.
   //
   // This is because, in general, groups should be "transparent" ways to add
   // groups of dependencies, so adding the groups deps make this happen with
@@ skipping 52 matching lines @@
 };
 #elif defined(COMPILER_MSVC)
 inline size_t hash_value(const Target* t) {
   return reinterpret_cast<size_t>(t);
 }
 #endif  // COMPILER...
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // TOOLS_GN_TARGET_H_