Don't make checkdeps ignore includes to directories that are brought in via deps.

tools/checkdeps/checkdeps.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Makes sure that files include headers from allowed directories.
 
 Checks DEPS files in the source tree for rules, and applies those rules to
 "#include" commands in source files. Any source file including something not
 permitted by the DEPS files will fail.
@@ skipping 41 matching lines @@
 only lowercase.
 """
 
 import os
 import optparse
 import pipes
 import re
 import sys
 import copy
 
-# Variable name used in the DEPS file to specify module-level deps.
-DEPS_VAR_NAME = "deps"
-
 # Variable name used in the DEPS file to add or subtract include files from
 # the module-level deps.
 INCLUDE_RULES_VAR_NAME = "include_rules"
 
 # Optionally present in the DEPS file to list subdirectories which should not
 # be checked. This allows us to skip third party code, for example.
 SKIP_SUBDIRS_VAR_NAME = "skip_child_includes"
 
 # The maximum number of lines to check in each source file before giving up.
 MAX_LINES = 150
@@ skipping 88 matching lines @@
     for rule in self._rules:
       if rule.ChildOrMatch(allowed_dir):
         # This rule applies.
         if rule._allow:
           return (True, "")
         return (False, rule.__str__())
     # No rules apply, fail.
     return (False, "no rule applying")
 
 
-def ApplyRules(existing_rules, deps, includes, cur_dir):
-  """Applies the given deps and include rules, returning the new rules.
+def ApplyRules(existing_rules, includes, cur_dir):
+  """Applies the given include rules, returning the new rules.
 
   Args:
     existing_rules: A set of existing rules that will be combined.
-    deps: The list of imports from the "deps" section of the DEPS file.
     include: The list of rules from the "include_rules" section of DEPS.
     cur_dir: The current directory. We will create an implicit rule that
              allows inclusion from this directory.
 
   Returns: A new set of rules combining the existing_rules with the other
            arguments.
   """
   rules = copy.copy(existing_rules)
 
   # First apply the implicit "allow" rule for the current directory.
   if cur_dir.lower().startswith(BASE_DIRECTORY):
     relative_dir = cur_dir[len(BASE_DIRECTORY) + 1:]
     # Normalize path separators to slashes.
     relative_dir = relative_dir.replace("\\", "/")
     source = relative_dir
     if len(source) == 0:
       source = "top level"  # Make the help string a little more meaningful.
     rules.AddRule("+" + relative_dir, "Default rule for " + source)
   else:
     raise Exception("Internal error: base directory is not at the beginning" +
                     " for\n  %s and base dir\n  %s" %
                     (cur_dir, BASE_DIRECTORY))
 
-  # Next apply the DEPS additions, these are all allowed. Note that DEPS start
-  # out with "src/" which we want to trim.
-  for (index, key) in enumerate(deps):
-    if key.startswith("src/"):
-      key = key[4:]
-    rules.AddRule("+" + key, relative_dir + "'s deps for " + key)
-
   # Last, apply the additional explicit rules.
   for (index, rule_str) in enumerate(includes):
     if not len(relative_dir):
       rule_description = "the top level include_rules"
     else:
       rule_description = relative_dir + "'s include_rules"
     rules.AddRule(rule_str, rule_description)
 
   return rules
 
@@ skipping 49 matching lines @@
       }
   deps_file = os.path.join(dir_name, "DEPS")
 
   if os.path.isfile(deps_file):
     execfile(deps_file, global_scope, local_scope)
   elif VERBOSE:
     print "  No deps file found in", dir_name
 
   # Even if a DEPS file does not exist we still invoke ApplyRules
   # to apply the implicit "allow" rule for the current directory
-  deps = local_scope.get(DEPS_VAR_NAME, {})
   include_rules = local_scope.get(INCLUDE_RULES_VAR_NAME, [])
   skip_subdirs = local_scope.get(SKIP_SUBDIRS_VAR_NAME, [])
 
-  return (ApplyRules(existing_rules, deps, include_rules, dir_name),
-          skip_subdirs)
+  return (ApplyRules(existing_rules, include_rules, dir_name), skip_subdirs)
 
 
 def ShouldCheckFile(file_name):
   """Returns True if the given file is a type we want to check."""
   checked_extensions = [
       '.h',
       '.cc',
       '.m',
       '.mm',
   ]
@@ skipping 211 matching lines @@
                            'to "../../.." relative to the script file, which '
                            'will normally be the repository root.')
   option_parser.add_option("-v", "--verbose", action="store_true",
                            default=False, help="Print debug logging")
   options, args = option_parser.parse_args()
   return checkdeps(options, args)
 
 
 if '__main__' == __name__:
   sys.exit(main())