Remove gclient_utils.CheckCall() from gclient_scm.py

gclient_scm.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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
@@ skipping 273 matching lines @@
         raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
 
     # Update the remotes first so we have all the refs.
     backoff_time = 5
     for _ in range(10):
       try:
         remote_output = scm.GIT.Capture(
             ['remote'] + verbose + ['update'],
             cwd=self.checkout_path)
         break
-      except gclient_utils.CheckCallError, e:
+      except subprocess2.CalledProcessError, e:
         # Hackish but at that point, git is known to work so just checking for
         # 502 in stderr should be fine.
         if '502' in e.stderr:
           print(str(e))
           print('Sleeping %.1f seconds and retrying...' % backoff_time)
           time.sleep(backoff_time)
           backoff_time *= 1.3
           continue
         raise
 
@@ skipping 48 matching lines @@
       # case 3 - the default case
       files = self._Capture(['diff', upstream_branch, '--name-only']).split()
       if verbose:
         print('Trying fast-forward merge to branch : %s' % upstream_branch)
       try:
         merge_args = ['merge']
         if not options.merge:
           merge_args.append('--ff-only')
         merge_args.append(upstream_branch)
         merge_output = scm.GIT.Capture(merge_args, cwd=self.checkout_path)
-      except gclient_utils.CheckCallError, e:
+      except subprocess2.CalledProcessError, e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           if not printed_path:
             print('\n_____ %s%s' % (self.relpath, rev_str))
             printed_path = True
           while True:
             try:
               # TODO(maruel): That can't work with --jobs.
               action = ask_for_data(
                   'Cannot fast-forward merge, attempt to rebase? '
                   '(y)es / (q)uit / (s)kip : ')
@@ skipping 127 matching lines @@
     parent_dir = os.path.dirname(self.checkout_path)
     if not os.path.exists(parent_dir):
       os.makedirs(parent_dir)
 
     for _ in range(3):
       try:
         self._Run(clone_cmd, options, cwd=self._root_dir)
         break
       except (gclient_utils.Error, subprocess2.CalledProcessError), e:
         # TODO(maruel): Hackish, should be fixed by moving _Run() to
-        # CheckCall().
+        # subprocess2.check_output().
         # Too bad we don't have access to the actual output.
         # We should check for "transfer closed with NNN bytes remaining to
         # read". In the meantime, just make sure .git exists.
         if (e.args[0] == 'git command clone returned 128' and
             os.path.exists(os.path.join(self.checkout_path, '.git'))):
           print(str(e))
           print('Retrying...')
           continue
         raise e
 
@@ skipping 26 matching lines @@
     if options.verbose:
       rebase_cmd.append('--verbose')
     if newbase:
       rebase_cmd.extend(['--onto', newbase])
     rebase_cmd.append(upstream)
     if branch:
       rebase_cmd.append(branch)
 
     try:
       rebase_output = scm.GIT.Capture(rebase_cmd, cwd=self.checkout_path)
-    except gclient_utils.CheckCallError, e:
+    except subprocess2.CalledProcessError, e:
       if (re.match(r'cannot rebase: you have unstaged changes', e.stderr) or
           re.match(r'cannot rebase: your index contains uncommitted changes',
                    e.stderr)):
         while True:
           rebase_action = ask_for_data(
               'Cannot rebase because of unstaged changes.\n'
               '\'git reset --hard HEAD\' ?\n'
               'WARNING: destroys any uncommitted work in your current branch!'
               ' (y)es / (q)uit / (s)how : ')
           if re.match(r'yes|y', rebase_action, re.I):
@@ skipping 43 matching lines @@
     g = os.path.join(self.checkout_path, '.git')
     return (
       os.path.isdir(os.path.join(g, "rebase-merge")) or
       os.path.isdir(os.path.join(g, "rebase-apply")))
 
   def _CheckClean(self, rev_str):
     # Make sure the tree is clean; see git-rebase.sh for reference
     try:
       scm.GIT.Capture(['update-index', '--ignore-submodules', '--refresh'],
                       cwd=self.checkout_path)
-    except gclient_utils.CheckCallError:
+    except subprocess2.CalledProcessError:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tYou have unstaged changes.\n'
                                 '\tPlease commit, stash, or reset.\n'
                                   % (self.relpath, rev_str))
     try:
       scm.GIT.Capture(['diff-index', '--cached', '--name-status', '-r',
                        '--ignore-submodules', 'HEAD', '--'],
                        cwd=self.checkout_path)
-    except gclient_utils.CheckCallError:
+    except subprocess2.CalledProcessError:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tYour index contains uncommitted changes\n'
                                 '\tPlease commit, stash, or reset.\n'
                                   % (self.relpath, rev_str))
 
   def _CheckDetachedHead(self, rev_str, options):
     # HEAD is detached. Make sure it is safe to move away from (i.e., it is
     # reference by a commit). If not, error out -- most likely a rebase is
     # in progress, try to detect so we can give a better error.
     try:
       scm.GIT.Capture(['name-rev', '--no-undefined', 'HEAD'],
           cwd=self.checkout_path)
-    except gclient_utils.CheckCallError:
+    except subprocess2.CalledProcessError:
       # Commit is not contained by any rev. See if the user is rebasing:
       if self._IsRebasing():
         # Punt to the user
         raise gclient_utils.Error('\n____ %s%s\n'
                                   '\tAlready in a conflict, i.e. (no branch).\n'
                                   '\tFix the conflict and run gclient again.\n'
                                   '\tOr to abort run:\n\t\tgit-rebase --abort\n'
                                   '\tSee man git-rebase for details.\n'
                                    % (self.relpath, rev_str))
       # Let's just save off the commit so we can proceed.
       name = ('saved-by-gclient-' +
               self._Capture(['rev-parse', '--short', 'HEAD']))
       self._Capture(['branch', name])
       print('\n_____ found an unreferenced commit and saved it as \'%s\'' %
           name)
 
   def _GetCurrentBranch(self):
     # Returns name of current branch or None for detached HEAD
     branch = self._Capture(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
     if branch == 'HEAD':
       return None
     return branch
 
   def _Capture(self, args):
-    return gclient_utils.CheckCall(
-        ['git'] + args, cwd=self.checkout_path, print_error=False)[0].strip()
+    return subprocess2.check_output(
+        ['git'] + args, cwd=self.checkout_path).strip()
 
   def _Run(self, args, options, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
     gclient_utils.CheckCallAndFilterAndHeader(['git'] + args,
         always=options.verbose, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
@@ skipping 259 matching lines @@
 
     This method returns a new list to be used as a command."""
     new_command = command[:]
     if revision:
       new_command.extend(['--revision', str(revision).strip()])
     # --force was added to 'svn update' in svn 1.5.
     if ((options.force or options.manually_grab_svn_rev) and
         scm.SVN.AssertVersion("1.5")[0]):
       new_command.append('--force')
     return new_command