Make GN header checker more lenient about toolchains.

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/files/file_util.h"
@@ skipping 302 matching lines @@
   // our include finder is too primitive and returns all includes, even if
   // they're in a #if not executed in the current build. In that case, it's
   // not unusual for the buildfiles to not specify that header at all.
   FileMap::const_iterator found = file_map_.find(include_file);
   if (found == file_map_.end())
     return true;
 
   const TargetVector& targets = found->second;
   Chain chain;  // Prevent reallocating in the loop.
 
+  // If the file is unknown in the current toolchain (rather than being private
+  // or in a target not visible to the current target), ignore it. This is a
+  // bit of a hack to account for the fact that the include finder doesn't
+  // understand the preprocessor.
+  //
+  // When not cross-compiling, if a platform specific header is conditionally
+  // included in the build, and preprocessor conditions around #includes of
+  // that match the build conditions, everything will be OK because the file
+  // won't be known to GN even though the #include finder identified the file.
+  //
+  // Cross-compiling breaks this. When compiling Android on Linux, for example,
+  // we might see both Linux and Android definitions of a target and know
+  // about the union of all headers in the build. Since the #include finder
+  // ignores preprocessor, we will find the Linux headers in the Android
+  // build and note that a dependency from the Android target to the Linux
+  // one is missing (these might even be the same target in different
+  // toolchains!).
+  bool present_in_current_toolchain = false;
+  for (const auto& target : targets) {
+    if (from_target->label().ToolchainsEqual(target.target->label())) {
+      present_in_current_toolchain = true;
+      break;
+    }
+  }
+  if (!present_in_current_toolchain)
+    return true;
+
   // For all targets containing this file, we require that at least one be
   // a direct or public dependency of the current target, and that the header
   // is public within the target.
   //
   // If there is more than one target containing this header, we may encounter
   // some error cases before finding a good one. This error stores the previous
   // one encountered, which we may or may not throw away.
   Err last_error;
 
   bool found_dependency = false;
   for (const auto& target : targets) {
     // We always allow source files in a target to include headers also in that
     // target.
     const Target* to_target = target.target;
     if (to_target == from_target)
       return true;
 
-    // Additionally, allow a target to include files from that same target
-    // in other toolchains. This is a bit of a hack to account for the fact that
-    // the include finder doesn't understand the preprocessor.
-    //
-    // If a source file conditionally depends on a platform-specific include in
-    // the same target, and there is a cross-compile such that GN sees
-    // definitions of the target both with and without that include, it would
-    // give an error that the target needs to depend on itself in the other
-    // toolchain (where the platform-specific header is defined as a source).
-    if (TargetLabelsMatchExceptToolchain(to_target, from_target))
-      return true;
-
     bool is_permitted_chain = false;
     if (IsDependencyOf(to_target, from_target, &chain, &is_permitted_chain)) {
       DCHECK(chain.size() >= 2);
       DCHECK(chain[0].target == to_target);
       DCHECK(chain[chain.size() - 1].target == from_target);
 
       found_dependency = true;
 
       if (target.is_public && is_permitted_chain) {
         // This one is OK, we're done.
@@ skipping 197 matching lines @@
   if (targets_with_other_toolchains.size() +
       targets_with_matching_toolchains.size() > 1)
     msg += "at least one of ";
   msg += "which should somehow be reachable.";
 
   // Danger: must call CreatePersistentRange to put in Err.
   return Err(CreatePersistentRange(source_file, range),
              "Include not allowed.", msg);
 }