Add GN variables for controlling header checking.

tools/gn/header_checker.cc

 // Copyright 2014 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/header_checker.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 112 matching lines @@
     : main_loop_(base::MessageLoop::current()),
       build_settings_(build_settings) {
   for (size_t i = 0; i < targets.size(); i++)
     AddTargetToFileMap(targets[i], &file_map_);
 }
 
 HeaderChecker::~HeaderChecker() {
 }
 
 bool HeaderChecker::Run(const std::vector<const Target*>& to_check,
+                        bool force_check,
                         std::vector<Err>* errors) {
   if (to_check.empty()) {
     // Check all files.
-    RunCheckOverFiles(file_map_);
+    RunCheckOverFiles(file_map_, force_check);
   } else {
     // Run only over the files in the given targets.
     FileMap files_to_check;
     for (size_t i = 0; i < to_check.size(); i++)
       AddTargetToFileMap(to_check[i], &files_to_check);
-    RunCheckOverFiles(files_to_check);
+    RunCheckOverFiles(files_to_check, force_check);
   }
 
   if (errors_.empty())
     return true;
   *errors = errors_;
   return false;
 }
 
-void HeaderChecker::RunCheckOverFiles(const FileMap& files) {
+void HeaderChecker::RunCheckOverFiles(const FileMap& files, bool force_check) {
   if (files.empty())
     return;
 
   scoped_refptr<base::SequencedWorkerPool> pool(
       new base::SequencedWorkerPool(16, "HeaderChecker"));
   for (FileMap::const_iterator file_i = files.begin();
        file_i != files.end(); ++file_i) {
     const TargetVector& vect = file_i->second;
 
     // Only check C-like source files (RC files also have includes).
     SourceFileType type = GetSourceFileType(file_i->first);
     if (type != SOURCE_CC && type != SOURCE_H && type != SOURCE_C &&
         type != SOURCE_M && type != SOURCE_MM && type != SOURCE_RC)
       continue;
 
+    // Do a first pass to find if this should be skipped. All targets including
+    // this source file must exclude it from checking.
+    if (!force_check) {
+      bool check_includes = false;
+      for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i)
+        check_includes |= vect[vect_i].target->check_includes();
+      if (!check_includes)
+        continue;
+    }
+
     for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i) {
       pool->PostWorkerTaskWithShutdownBehavior(
           FROM_HERE,
           base::Bind(&HeaderChecker::DoWork, this,
                      vect[vect_i].target, file_i->first),
           base::SequencedWorkerPool::BLOCK_SHUTDOWN);
     }
   }
 
   // After this call we're single-threaded again.
@@ skipping 166 matching lines @@
       if (has_direct_dependent_compiler_settings &&
           !direct_dependent_configs_apply) {
         size_t problematic_index = GetDependentConfigChainProblemIndex(chain);
         *err = Err(CreatePersistentRange(source_file, range),
                    "Can't include this header from here.",
                    GetDependentConfigChainError(chain, problematic_index));
         return false;
       }
 
       found_dependency = true;
+    } else if (
+        to_target->allow_circular_includes_from().find(from_target->label()) !=
+        to_target->allow_circular_includes_from().end()) {
+      // Not a dependency, but this include is whitelisted from the destination.
+      found_dependency = true;
     }
   }
 
   if (!found_dependency) {
     std::string msg = "It is not in any dependency of " +
         from_target->label().GetUserVisibleName(false);
     msg += "\nThe include file is in the target(s):\n";
     for (size_t i = 0; i < targets.size(); i++)
       msg += "  " + targets[i].target->label().GetUserVisibleName(false) + "\n";
     if (targets.size() > 1)
@@ skipping 134 matching lines @@
         chain[i]->forward_dependent_configs();
     if (std::find_if(forwarded.begin(), forwarded.end(),
                      LabelPtrPtrEquals<Target>(chain[i - 1])) ==
         forwarded.end())
       return i;
   }
 
   CHECK(false) << "Unable to diagnose dependent config chain problem.";
   return 0;
 }