Add verbose support throught presubmit checks

presubmit_canned_checks.py

 # Copyright (c) 2010 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.
 
 """Generic presubmit checks that can be reused by other presubmit checks."""
 
 
 ### Description checks
 
 def CheckChangeHasTestField(input_api, output_api):
@@ skipping 393 matching lines @@
       if input_api.re.match(closed, status):
         long_text = status + '\n' + url
         return [output_api.PresubmitError('The tree is closed.',
                                           long_text=long_text)]
   except IOError:
     pass
   return []
 
 
 def RunUnitTestsInDirectory(
-    input_api, output_api, directory, whitelist=None, blacklist=None,
-    verbose=False):
+    input_api, output_api, directory, whitelist=None, blacklist=None):
   """Lists all files in a directory and runs them. Doesn't recurse.
 
   It's mainly a wrapper for RunUnitTests. USe whitelist and blacklist to filter
   tests accordingly.
   """
   unit_tests = []
   test_path = input_api.os_path.abspath(
       input_api.os_path.join(input_api.PresubmitLocalPath(), directory))
 
   def check(filename, filters):
     return any(True for i in filters if input_api.re.match(i, filename))
 
   for filename in input_api.os_listdir(test_path):
     fullpath = input_api.os_path.join(test_path, filename)
     if not input_api.os_path.isfile(fullpath):
       continue
     if whitelist and not check(filename, whitelist):
       continue
     if blacklist and check(filename, blacklist):
       continue
     unit_tests.append(input_api.os_path.join(directory, filename))
-  return RunUnitTests(input_api, output_api, unit_tests, verbose)
+  return RunUnitTests(input_api, output_api, unit_tests)
 
 
-def RunUnitTests(input_api, output_api, unit_tests, verbose=False):
+def RunUnitTests(input_api, output_api, unit_tests):
   """Runs all unit tests in a directory.
 
   On Windows, sys.executable is used for unit tests ending with ".py".
   """
   # We don't want to hinder users from uploading incomplete patches.
   if input_api.is_committing:
     message_type = output_api.PresubmitError
   else:
     message_type = output_api.PresubmitPromptWarning
 
   results = []
   for unit_test in unit_tests:
     cmd = []
     if input_api.platform == 'win32' and unit_test.endswith('.py'):
       # Windows needs some help.
       cmd = [input_api.python_executable]
     cmd.append(unit_test)
-    if verbose:
+    if input_api.verbose:
       print('Running %s' % unit_test)
     try:
-      if verbose:
+      if input_api.verbose:
         input_api.subprocess.check_call(cmd, cwd=input_api.PresubmitLocalPath())
       else:
         input_api.subprocess.check_output(
             cmd, cwd=input_api.PresubmitLocalPath())
     except (OSError, input_api.subprocess.CalledProcessError), e:
       results.append(message_type('%s failed!\n%s' % (unit_test, e)))
   return results
 
 
 def RunPythonUnitTests(input_api, output_api, unit_tests):
@@ skipping 65 matching lines @@
       if Find(filepath, white_list) and not Find(filepath, black_list):
         files.append(filepath)
   return files
 
 
 def RunPylint(input_api, output_api, white_list=None, black_list=None):
   """Run pylint on python files.
 
   The default white_list enforces looking only a *.py files.
   """
-  verbose = False
   white_list = white_list or ['.*\.py$']
   black_list = black_list or input_api.DEFAULT_BLACK_LIST
   if input_api.is_committing:
     error_type = output_api.PresubmitError
   else:
     error_type = output_api.PresubmitPromptWarning
 
   # Only trigger if there is at least one python file affected.
   src_filter = lambda x: input_api.FilterSourceFile(x, white_list, black_list)
   if not input_api.AffectedSourceFiles(src_filter):
@@ skipping 25 matching lines @@
 
     def run_lint(files):
       try:
         lint.Run(files)
         assert False
       except SystemExit, e:
         # pylint has the bad habit of calling sys.exit(), trap it here.
         return e.code
 
     result = None
-    if not verbose:
+    if not input_api.verbose:
       result = run_lint(sorted(files))
     else:
       for filename in sorted(files):
         print('Running pylint on %s' % filename)
         out = run_lint([filename])
         if out:
           result = out
     if result:
       return [error_type('Fix pylint errors first.')]
     return []
@@ skipping 291 matching lines @@
       input_api, output_api, source_file_filter=text_files))
   results.extend(input_api.canned_checks.CheckSvnForCommonMimeTypes(
       input_api, output_api))
   results.extend(input_api.canned_checks.CheckLicense(
       input_api, output_api, license_header, source_file_filter=sources))
   results.extend(_CheckConstNSObject(
       input_api, output_api, source_file_filter=sources))
   results.extend(_CheckSingletonInHeaders(
       input_api, output_api, source_file_filter=sources))
   return results