Fix python scripts in src/tools/

tools/checkdeps/checkdeps.py

-#!/usr/bin/python
+#!/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 72 matching lines @@
 # statements.
 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 = ""
 
 # The directories which contain the sources managed by git.
 GIT_SOURCE_DIRECTORY = set()
 
+
 # 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
     self._source = source
 
   def __str__(self):
     if (self._allow):
       return '"+%s" from %s.' % (self._dir, self._source)
@@ skipping 334 matching lines @@
            of the script in "<root>/tools/checkdeps".
 
   tocheck  Specifies the directory, relative to root, to check. This defaults
            to "." so it checks everything. Only one level deep is currently
            supported, so you can say "chrome" but not "chrome/browser".
 
 Examples:
   python checkdeps.py
   python checkdeps.py --root c:\\source chrome"""
 
-def main(options, args):
+
+def checkdeps(options, args):
   global VERBOSE
   if options.verbose:
     VERBOSE = True
 
   # Optional base directory of the repository.
   global BASE_DIRECTORY
   if not options.base_directory:
     BASE_DIRECTORY = os.path.abspath(
         os.path.join(os.path.abspath(os.path.dirname(__file__)), "../.."))
   else:
     BASE_DIRECTORY = os.path.abspath(options.base_directory)
 
   # Figure out which directory we have to check.
   if len(args) == 0:
     # No directory to check specified, use the repository root.
     start_dir = BASE_DIRECTORY
   elif len(args) == 1:
     # Directory specified. Start here. It's supposed to be relative to the
     # base directory.
     start_dir = os.path.abspath(os.path.join(BASE_DIRECTORY, args[0]))
   else:
     # More than one argument, we don't handle this.
     PrintUsage()
-    sys.exit(1)
+    return 1
 
   print "Using base directory:", BASE_DIRECTORY
   print "Checking:", start_dir
 
   base_rules = Rules()
 
   # The base directory should be lower case from here on since it will be used
   # for substring matching on the includes, and we compile on case-insensitive
   # systems. Plus, we always use slashes here since the include parsing code
   # will also normalize to slashes.
   BASE_DIRECTORY = BASE_DIRECTORY.lower()
   BASE_DIRECTORY = BASE_DIRECTORY.replace("\\", "/")
   start_dir = start_dir.replace("\\", "/")
 
   if os.path.exists(os.path.join(BASE_DIRECTORY, ".git")):
     global GIT_SOURCE_DIRECTORY
     GIT_SOURCE_DIRECTORY = GetGitSourceDirectory(BASE_DIRECTORY)
 
   success = CheckDirectory(base_rules, start_dir)
   if not success:
     print "\nFAILED\n"
-    sys.exit(1)
+    return 1
   print "\nSUCCESS\n"
-  sys.exit(0)
+  return 0
 
-if '__main__' == __name__:
+
+def main():
   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)
+  return checkdeps(options, args)
+
+
+if '__main__' == __name__:
+  sys.exit(main())