Also scan .m and .mm files in checkdeps.py

tools/checkdeps/checkdeps.py

 #!/usr/bin/python
 # Copyright (c) 2006-2008 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 51 matching lines @@
 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"
 
-# We'll search for lines beginning with this string for checking.
-INCLUDE_PREFIX = "#include"
-
 # The maximum number of lines to check in each source file before giving up.
 MAX_LINES = 150
 
 # 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.
-EXTRACT_INCLUDE_FILENAME = re.compile(INCLUDE_PREFIX + ' *"(.*)"')
+EXTRACT_INCLUDE_PATH = re.compile('[ \t]*#[ \t]*(?:include|import)[ \t]+"(.*)"')
 
 # In lowercase, using forward slashes as directory separators, ending in a
 # forward slash. Set by the command line options.
 BASE_DIRECTORY = ""
 
 # Specifies a single rule for an include, which can be either allow or disallow.
 class Rule(object):
   def __init__(self, allow, dir, source):
     self._allow = allow
     self._dir = dir
@@ skipping 169 matching lines @@
   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)
 
 
 def ShouldCheckFile(file_name):
   """Returns True if the given file is a type we want to check."""
-  if len(file_name) < 2:
-    return False
-  return file_name.endswith(".cc") or file_name.endswith(".h")
+  checked_extensions = [
+      '.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."""
-  if line[0:8] != "#include":
-    return None  # Not an include line
-
-  found_item = EXTRACT_INCLUDE_FILENAME.match(line)
+  found_item = EXTRACT_INCLUDE_PATH.match(line)
   if not found_item:
     return 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
@@ skipping 159 matching lines @@
 if '__main__' == __name__:
   option_parser = optparse.OptionParser()
   option_parser.add_option("", "--root", default="", dest="base_directory",
                            help='Specifies the repository root. This defaults '
                            '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()
   main(options, args)