Change checkdeps.py to stop scanning after a certain number of non-include lines.

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 49 matching lines @@
 import copy
 
 # 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
+# The maximum number of non-include lines we can see before giving up.
+MAX_UNINTERESTING_LINES = 50
 
 # The maximum line length, this is to be efficient in the case of very long
 # lines (which can't be #includes).
 MAX_LINE_LENGTH = 128
 
 # Set to true for more output. This is set by the command line options.
 VERBOSE = False
 
 # This regular expression will be used to extract filenames from include
 # statements.
@@ skipping 194 matching lines @@
       '.h',
       '.cc',
       '.m',
       '.mm',
   ]
   basename, extension = os.path.splitext(file_name)
   return extension in checked_extensions
 
 
 def CheckLine(rules, line):
-  """Checks the given file with the given rule set. If the line is an #include
-  directive and is illegal, a string describing the error will be returned.
-  Otherwise, None will be returned."""
+  """Checks the given file with the given rule set.
+  Returns a tuple (is_include, illegal_description).
+  If the line is an #include directive the first value will be True.
+  If it is also an illegal include, the second value will be a string describing
+  the error.  Otherwise, it will be None."""
   found_item = EXTRACT_INCLUDE_PATH.match(line)
   if not found_item:
-    return None  # Not a match
+    return False, None  # Not a match
 
   include_path = found_item.group(1)
 
   # Fix up backslashes in case somebody accidentally used them.
   include_path.replace("\\", "/")
 
   if include_path.find("/") < 0:
     # Don't fail when no directory is specified. We may want to be more
     # strict about this in the future.
     if VERBOSE:
       print " WARNING: directory specified with no path: " + include_path
-    return None
+    return True, None
 
   (allowed, why_failed) = rules.DirAllowed(include_path)
   if not allowed:
     if VERBOSE:
       retval = "\nFor " + rules.__str__()
     else:
       retval = ""
-    return retval + ('Illegal include: "%s"\n    Because of %s' %
+    return True, retval + ('Illegal include: "%s"\n    Because of %s' %
         (include_path, why_failed))
 
-  return None
+  return True, None
 
 
 def CheckFile(rules, file_name):
   """Checks the given file with the given rule set.
 
   Args:
     rules: The set of rules that apply to files in this directory.
     file_name: The source file to check.
 
   Returns: Either a string describing the error if there was one, or None if
            the file checked out OK.
   """
   if VERBOSE:
     print "Checking: " + file_name
 
   ret_val = ""  # We'll collect the error messages in here
+  last_include = 0
   try:
     cur_file = open(file_name, "r")
     in_if0 = 0
-    for cur_line in range(MAX_LINES):
-      cur_line = cur_file.readline(MAX_LINE_LENGTH).strip()
+    for line_num in xrange(sys.maxint):
+      if line_num - last_include > MAX_UNINTERESTING_LINES:
+        break
+
+      cur_line = cur_file.readline(MAX_LINE_LENGTH)
+      if cur_line == "":
+        break
+      cur_line = cur_line.strip()
 
       # Check to see if we're at / inside a #if 0 block
       if cur_line == '#if 0':
         in_if0 += 1
         continue
       if in_if0 > 0:
         if cur_line.startswith('#if'):
           in_if0 += 1
         elif cur_line == '#endif':
           in_if0 -= 1
         continue
 
-      line_status = CheckLine(rules, cur_line)
+      is_include, line_status = CheckLine(rules, cur_line)
+      if is_include:
+        last_include = line_num
       if line_status is not None:
         if len(line_status) > 0:  # Add newline to separate messages.
           line_status += "\n"
         ret_val += line_status
     cur_file.close()
 
   except IOError:
     if VERBOSE:
       print "Unable to open file: " + file_name
     cur_file.close()
@@ skipping 133 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())