Enhance GN diagnostic tools

tools/gn/header_checker.h

 // 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.
 
 #ifndef TOOLS_GN_HEADER_CHECKER_H_
 #define TOOLS_GN_HEADER_CHECKER_H_
 
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 15 matching lines @@
 
 namespace base {
 class MessageLoop;
 }
 
 class HeaderChecker : public base::RefCountedThreadSafe<HeaderChecker> {
  public:
   HeaderChecker(const BuildSettings* build_settings,
                 const std::vector<const Target*>& targets);
 
-  // This assumes that the current thread already has a message loop.  On
-  // error, fills the given vector with the errors and returns false.  Returns
+  // Runs the check. The targets in to_check will be checked. If this list is
+  // empty, all targets will be checked.
+  //
+  // This assumes that the current thread already has a message loop. On
+  // error, fills the given vector with the errors and returns false. Returns
   // true on success.
-  bool Run(std::vector<Err>* errors);
+  bool Run(const std::vector<const Target*>& to_check,
+           std::vector<Err>* errors);
 
  private:
   friend class base::RefCountedThreadSafe<HeaderChecker>;
   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, IsDependencyOf);
   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest,
                            IsDependencyOf_ForwardsDirectDependentConfigs);
   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, CheckInclude);
   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest,
                            GetDependentConfigChainProblemIndex);
   ~HeaderChecker();
 
   struct TargetInfo {
     TargetInfo() : target(NULL), is_public(false) {}
     TargetInfo(const Target* t, bool p) : target(t), is_public(p) {}
 
     const Target* target;
     bool is_public;
   };
 
   typedef std::vector<TargetInfo> TargetVector;
+  typedef std::map<SourceFile, TargetVector> FileMap;
+
+  // Backend for Run() that takes the list of files to check. The errors_ list
+  // will be populate on failure.
+  void RunCheckOverFiles(const FileMap& flies);
 
   void DoWork(const Target* target, const SourceFile& file);
 
-  // Adds the sources and public files from the given target to the file_map_.
-  // Not threadsafe! Called only during init.
-  void AddTargetToFileMap(const Target* target);
+  // Adds the sources and public files from the given target to the given map.
+  static void AddTargetToFileMap(const Target* target, FileMap* dest);
 
   // Returns true if the given file is in the output directory.
   bool IsFileInOuputDir(const SourceFile& file) const;
 
   // Resolves the contents of an include to a SourceFile.
   SourceFile SourceFileForInclude(const base::StringPiece& input) const;
 
   // from_target is the target the file was defined from. It will be used in
   // error messages.
   bool CheckFile(const Target* from_target,
@@ skipping 50 matching lines @@
   //
   // These are initialized during construction (which happens on one thread)
   // and are not modified after, so any thread can read these without locking.
 
   base::MessageLoop* main_loop_;
   base::RunLoop main_thread_runner_;
 
   const BuildSettings* build_settings_;
 
   // Maps source files to targets it appears in (usually just one target).
-  typedef std::map<SourceFile, TargetVector> FileMap;
   FileMap file_map_;
 
   // Locked variables ----------------------------------------------------------
   //
   // These are mutable during runtime and require locking.
 
   base::Lock lock_;
 
   std::vector<Err> errors_;
 
   DISALLOW_COPY_AND_ASSIGN(HeaderChecker);
 };
 
 #endif  // TOOLS_GN_HEADER_CHECKER_H_