Cleanup the code in gclient_utils to standardize on CheckCall nomenclature.

scm.py

 # Copyright (c) 2006-2009 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.
 
 """SCM-specific utility classes."""
 
 import cStringIO
 import glob
 import os
 import re
@@ skipping 47 matching lines @@
   # Prepend '+' to every lines.
   for line in file_content:
     data.write('+')
     data.write(line)
   result = data.getvalue()
   data.close()
   return result
 
 
 class GIT(object):
-  COMMAND = "git"
-
   @staticmethod
   def Capture(args, in_directory=None, print_error=True, error_ok=False):
     """Runs git, capturing output sent to stdout as a string.
 
     Args:
       args: A sequence of command line parameters to be passed to git.
       in_directory: The directory where git is to be run.
 
     Returns:
       The output sent to stdout as a string.
     """
-    c = [GIT.COMMAND]
-    c.extend(args)
     try:
-      return gclient_utils.CheckCall(c, in_directory, print_error)
+      return gclient_utils.CheckCall(['git'] + args, in_directory, print_error)
     except gclient_utils.CheckCallError:
       if error_ok:
         return ('', '')
       raise
 
   @staticmethod
   def CaptureStatus(files, upstream_branch=None):
     """Returns git status.
 
     @files can be a string (one file) or a list of files.
@@ skipping 15 matching lines @@
     results = []
     if status:
       for statusline in status.split('\n'):
         m = re.match('^(\w)\t(.+)$', statusline)
         if not m:
           raise Exception("status currently unsupported: %s" % statusline)
         results.append(('%s      ' % m.group(1), m.group(2)))
     return results
 
   @staticmethod
-  def RunAndFilterOutput(args, **kwargs):
-    """Wrapper to gclient_utils.SubprocessCallAndFilter()."""
-    return gclient_utils.SubprocessCallAndFilter([GIT.COMMAND] + args, **kwargs)
-
-  @staticmethod
   def GetEmail(repo_root):
     """Retrieves the user email address if known."""
     # We could want to look at the svn cred when it has a svn remote but it
     # should be fine for now, users should simply configure their git settings.
     return GIT.Capture(['config', 'user.email'],
                        repo_root, error_ok=True)[0].strip()
 
   @staticmethod
   def ShortBranchName(branch):
     """Converts a name like 'refs/heads/foo' to just 'foo'."""
@@ skipping 170 matching lines @@
     for min_ver in map(int, min_version.split('.')):
       ver = current_version_list.pop(0)
       if ver < min_ver:
         return (False, current_version)
       elif ver > min_ver:
         return (True, current_version)
     return (True, current_version)
 
 
 class SVN(object):
-  COMMAND = "svn"
   current_version = None
 
   @staticmethod
   def Run(args, **kwargs):
-    """Wrappers to gclient_utils.SubprocessCall()."""
-    return gclient_utils.SubprocessCall([SVN.COMMAND] + args, **kwargs)
+    """Wrappers to gclient_utils.CheckCallAndFilterAndHeader()."""
+    return gclient_utils.CheckCallAndFilterAndHeader(['svn'] + args,
+        always=True, **kwargs)
 
   @staticmethod
   def Capture(args, in_directory=None, print_error=True):
     """Runs svn, capturing output sent to stdout as a string.
 
     Args:
       args: A sequence of command line parameters to be passed to svn.
       in_directory: The directory where svn is to be run.
 
     Returns:
       The output sent to stdout as a string.
     """
-    c = [SVN.COMMAND]
-    c.extend(args)
     stderr = None
     if not print_error:
       stderr = subprocess.PIPE
-    return gclient_utils.Popen(c, cwd=in_directory, stdout=subprocess.PIPE,
-        stderr=stderr).communicate()[0]
+    return gclient_utils.Popen(['svn'] + args, cwd=in_directory,
+        stdout=subprocess.PIPE, stderr=stderr).communicate()[0]
 
   @staticmethod
   def RunAndGetFileList(verbose, args, cwd, file_list, stdout=None):
     """Runs svn checkout, update, or status, output to stdout.
 
     The first item in args must be either "checkout", "update", or "status".
 
     svn's stdout is parsed to collect a list of files checked out or updated.
     These files are appended to file_list.  svn's stdout is also printed to
     sys.stdout as in Run.
@@ skipping 35 matching lines @@
       failure = []
 
       def CaptureMatchingLines(line):
         match = compiled_pattern.search(line)
         if match:
           file_list.append(match.group(1))
         if line.startswith('svn: '):
           failure.append(line)
 
       try:
-        SVN.RunAndFilterOutput(args, cwd=cwd, print_messages=verbose,
-                               print_stdout=True,
-                               filter_fn=CaptureMatchingLines,
-                               stdout=stdout)
+        gclient_utils.CheckCallAndFilterAndHeader(
+            ['svn'] + args,
+            cwd=cwd,
+            always=verbose,
+            filter_fn=CaptureMatchingLines,
+            stdout=stdout)
       except gclient_utils.Error:
         def IsKnownFailure():
           for x in failure:
             if (x.startswith('svn: OPTIONS of') or
                 x.startswith('svn: PROPFIND of') or
                 x.startswith('svn: REPORT of') or
                 x.startswith('svn: Unknown hostname') or
                 x.startswith('svn: Server sent unexpected return value')):
               return True
           return False
@@ skipping 21 matching lines @@
           # We enforce that some progress has been made or a known failure.
           if len(file_list) == previous_list_len and not IsKnownFailure():
             # No known svn error was found and no progress, bail out.
             raise
         print "Sleeping 15 seconds and retrying...."
         time.sleep(15)
         continue
       break
 
   @staticmethod
-  def RunAndFilterOutput(args, **kwargs):
-    """Wrapper for gclient_utils.SubprocessCallAndFilter()."""
-    return gclient_utils.SubprocessCallAndFilter([SVN.COMMAND] + args, **kwargs)
-
-  @staticmethod
   def CaptureInfo(relpath, in_directory=None, print_error=True):
     """Returns a dictionary from the svn info output for the given file.
 
     Args:
       relpath: The directory where the working copy resides relative to
         the directory given by in_directory.
       in_directory: The directory where svn is to be run.
     """
     output = SVN.Capture(["info", "--xml", relpath], in_directory, print_error)
     dom = gclient_utils.ParseXML(output)
@@ skipping 406 matching lines @@
     if not SVN.current_version:
       SVN.current_version = SVN.Capture(['--version']).split()[2]
     current_version_list = map(only_int, SVN.current_version.split('.'))
     for min_ver in map(int, min_version.split('.')):
       ver = current_version_list.pop(0)
       if ver < min_ver:
         return (False, SVN.current_version)
       elif ver > min_ver:
         return (True, SVN.current_version)
     return (True, SVN.current_version)