Add GN variables for controlling header checking.

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 73 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_; }
 
+  // Whether this target's includes should be checked by "gn check".
+  bool check_includes() const { return check_includes_; }
+  void set_check_includes(bool ci) { check_includes_ = ci; }
+
   // 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 37 matching lines @@
 
   // A list of a subset of deps where we'll re-export direct_dependent_configs
   // as direct_dependent_configs of this target.
   const UniqueVector<LabelTargetPair>& forward_dependent_configs() const {
     return forward_dependent_configs_;
   }
   UniqueVector<LabelTargetPair>& forward_dependent_configs() {
     return forward_dependent_configs_;
   }
 
+  // Dependencies that can include files from this target.
+  const std::set<Label>& allow_circular_includes_from() const {
+    return allow_circular_includes_from_;
+  }
+  std::set<Label>& allow_circular_includes_from() {
+    return allow_circular_includes_from_;
+  }
+
   const UniqueVector<const Target*>& inherited_libraries() const {
     return inherited_libraries_;
   }
 
   // This config represents the configuration set directly on this target.
   ConfigValues& config_values() { return config_values_; }
   const ConfigValues& config_values() const { return config_values_; }
 
   ActionValues& action_values() { return action_values_; }
   const ActionValues& action_values() const { return action_values_; }
@@ skipping 49 matching lines @@
   // Fills the link and dependency output files when a target is resolved.
   void FillOutputFiles();
 
   OutputType output_type_;
   std::string output_name_;
   std::string output_extension_;
 
   FileList sources_;
   bool all_headers_public_;
   FileList public_headers_;
+  bool check_includes_;
   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
   // no additional complexity when iterating over a target's deps.
   //
   // However, a group may also have specific settings and configs added to it,
   // so we also need the group in the list so we find these things. But you
   // shouldn't need to look inside the deps of the group since those will
   // already be added.
   LabelTargetVector deps_;
   LabelTargetVector datadeps_;
 
   UniqueVector<LabelConfigPair> configs_;
   UniqueVector<LabelConfigPair> all_dependent_configs_;
   UniqueVector<LabelConfigPair> direct_dependent_configs_;
   UniqueVector<LabelTargetPair> forward_dependent_configs_;
 
+  std::set<Label> allow_circular_includes_from_;
+
   bool external_;
 
   // Static libraries and source sets from transitive deps. These things need
   // to be linked only with the end target (executable, shared library). Source
   // sets do not get pushed beyond static library boundaries, and neither
   // source sets nor static libraries get pushed beyond sahred library
   // boundaries.
   UniqueVector<const Target*> inherited_libraries_;
 
   // These libs and dirs are inherited from statically linked deps and all
@@ skipping 28 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_