Improve GN header checker, make //ui pass.

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 12 matching lines @@
 class LocationRange;
 class SourceFile;
 class Target;
 
 namespace base {
 class MessageLoop;
 }
 
 class HeaderChecker : public base::RefCountedThreadSafe<HeaderChecker> {
  public:
+  // Represents a dependency chain.
+  struct ChainLink {
+    ChainLink() : target(NULL), is_public(false) {}
+    ChainLink(const Target* t, bool p) : target(t), is_public(p) {}
+
+    const Target* target;
+
+    // True when the dependency on this target is public.
+    bool is_public;
+
+    // Used for testing.
+    bool operator==(const ChainLink& other) const {
+      return target == other.target && is_public == other.is_public;
+    }
+  };
+  typedef std::vector<ChainLink> Chain;
+
   HeaderChecker(const BuildSettings* build_settings,
                 const std::vector<const Target*>& targets);
 
   // 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.
   //
   // force_check, if true, will override targets opting out of header checking
   // with "check_includes = false" and will check them anyway.
   bool Run(const std::vector<const Target*>& to_check,
            bool force_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, PublicFirst);
   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, CheckIncludeAllowCircular);
-  FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest,
-                           GetDependentConfigChainProblemIndex);
   ~HeaderChecker();
 
   struct TargetInfo {
     TargetInfo() : target(NULL), is_public(false), is_generated(false) {}
     TargetInfo(const Target* t, bool is_pub, bool is_gen)
         : target(t),
           is_public(is_pub),
           is_generated(is_gen) {
     }
 
@@ skipping 40 matching lines @@
                     const LocationRange& range,
                     Err* err) const;
 
   // Returns true if the given search_for target is a dependency of
   // search_from.
   //
   // If found, the vector given in "chain" will be filled with the reverse
   // dependency chain from the dest target (chain[0] = search_for) to the src
   // target (chain[chain.size() - 1] = search_from).
   //
-  // Chains with public dependencies will be considered first. If a public
-  // match is found, *is_public will be set to true. A chain with non-public
-  // dependencies will only be considered if there are no public chains. In
-  // this case, *is_public will be false.
+  // Chains with permitted dependencies will be considered first. If a
+  // permitted match is found, *is_permitted will be set to true. A chain with
+  // indirect, non-public dependencies will only be considered if there are no
+  // public or direct chains. In this case, *is_permitted will be false.
+  //
+  // A permitted dependency is a sequence of public dependencies. The first
+  // one may be private, since a direct dependency always allows headers to be
+  // included.
   bool IsDependencyOf(const Target* search_for,
                       const Target* search_from,
-                      std::vector<const Target*>* chain,
-                      bool* is_public) const;
+                      Chain* chain,
+                      bool* is_permitted) const;
 
   // For internal use by the previous override of IsDependencyOf.  If
   // require_public is true, only public dependency chains are searched.
   bool IsDependencyOf(const Target* search_for,
                       const Target* search_from,
-                      bool require_public,
-                      std::vector<const Target*>* chain) const;
+                      bool require_permitted,
+                      Chain* chain) const;
 
   // Non-locked variables ------------------------------------------------------
   //
   // 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).
   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_