Enhance GN diagnostic tools

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 105 matching lines @@
       "to MID. This will apply DEST's direct dependent configs to SOURCE.\n";
 }
 
 }  // namespace
 
 HeaderChecker::HeaderChecker(const BuildSettings* build_settings,
                              const std::vector<const Target*>& targets)
     : main_loop_(base::MessageLoop::current()),
       build_settings_(build_settings) {
   for (size_t i = 0; i < targets.size(); i++)
-    AddTargetToFileMap(targets[i]);
+    AddTargetToFileMap(targets[i], &file_map_);
 }
 
 HeaderChecker::~HeaderChecker() {
 }
 
-bool HeaderChecker::Run(std::vector<Err>* errors) {
-  ScopedTrace trace(TraceItem::TRACE_CHECK_HEADERS, "Check headers");
+bool HeaderChecker::Run(const std::vector<const Target*>& to_check,
+                        std::vector<Err>* errors) {
+  if (to_check.empty()) {
+    // Check all files.
+    RunCheckOverFiles(file_map_);
+  } 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);
+  }
 
-  if (file_map_.empty())
+  if (errors_.empty())
     return true;
+  *errors = errors_;
+  return false;
+}
+
+void HeaderChecker::RunCheckOverFiles(const FileMap& files) {
+  if (files.empty())
+    return;
 
   scoped_refptr<base::SequencedWorkerPool> pool(
       new base::SequencedWorkerPool(16, "HeaderChecker"));
-  for (FileMap::const_iterator file_i = file_map_.begin();
-       file_i != file_map_.end(); ++file_i) {
+  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;
 
     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.
   pool->Shutdown();
-
-  if (errors_.empty())
-    return true;
-  *errors = errors_;
-  return false;
 }
 
 void HeaderChecker::DoWork(const Target* target, const SourceFile& file) {
   Err err;
   if (!CheckFile(target, file, &err)) {
     base::AutoLock lock(lock_);
     errors_.push_back(err);
   }
 }
 
-void HeaderChecker::AddTargetToFileMap(const Target* target) {
+// static
+void HeaderChecker::AddTargetToFileMap(const Target* target, FileMap* dest) {
   // Files in the sources have this public bit by default.
   bool default_public = target->all_headers_public();
 
   // First collect the normal files, they get the default visibility.
   std::map<SourceFile, bool> files_to_public;
   const Target::FileList& sources = target->sources();
   for (size_t i = 0; i < sources.size(); i++)
     files_to_public[sources[i]] = default_public;
 
   // Add in the public files, forcing them to public. This may overwrite some
   // entries, and it may add new ones.
   const Target::FileList& public_list = target->public_headers();
   if (default_public)
     DCHECK(public_list.empty());  // List only used when default is not public.
   for (size_t i = 0; i < public_list.size(); i++)
     files_to_public[public_list[i]] = true;
 
   // Add the merged list to the master list of all files.
   for (std::map<SourceFile, bool>::const_iterator i = files_to_public.begin();
        i != files_to_public.end(); ++i)
-    file_map_[i->first].push_back(TargetInfo(target, i->second));
+    (*dest)[i->first].push_back(TargetInfo(target, i->second));
 }
 
 bool HeaderChecker::IsFileInOuputDir(const SourceFile& file) const {
   const std::string& build_dir = build_settings_->build_dir().value();
   return file.value().compare(0, build_dir.size(), build_dir) == 0;
 }
 
 // This current assumes all include paths are relative to the source root
 // which is generally the case for Chromium.
 //
@@ skipping 276 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;
 }