Rewrite git gclient sync/update to be simpler and more reliable

gclient_scm.py

 # Copyright (c) 2012 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."""
 
 from __future__ import print_function
 
 import errno
 import logging
@@ skipping 287 matching lines @@
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff'] + merge_base,
         cwd=self.checkout_path,
         filter_fn=GitDiffFilterer(self.relpath, print_func=self.Print).Filter)
 
   def _FetchAndReset(self, revision, file_list, options):
     """Equivalent to git fetch; git reset."""
     quiet = []
     if not options.verbose:
       quiet = ['--quiet']
-    self._UpdateBranchHeads(options, fetch=False)
+    self._ConfigBranchHeads(options)
 
     self._Fetch(options, prune=True, quiet=options.verbose)
     self._Run(['reset', '--hard', revision] + quiet, options)
     if file_list is not None:
       files = self._Capture(['ls-files']).splitlines()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def _DisableHooks(self):
     hook_dir = os.path.join(self.checkout_path, '.git', 'hooks')
     if not os.path.isdir(hook_dir):
       return
     for f in os.listdir(hook_dir):
       if not f.endswith('.sample') and not f.endswith('.disabled'):
         disabled_hook_path = os.path.join(hook_dir, f + '.disabled')
         if os.path.exists(disabled_hook_path):
           os.remove(disabled_hook_path)
         os.rename(os.path.join(hook_dir, f), disabled_hook_path)
 
-  def _maybe_break_locks(self, options):
+  def _MaybeBreakLocks(self, options):
     """This removes all .lock files from this repo's .git directory, if the
     user passed the --break_repo_locks command line flag.
 
     In particular, this will cleanup index.lock files, as well as ref lock
     files.
     """
     if options.break_repo_locks:
       git_dir = os.path.join(self.checkout_path, '.git')
       for path, _, filenames in os.walk(git_dir):
         for filename in filenames:
           if filename.endswith('.lock'):
             to_break = os.path.join(path, filename)
             self.Print('breaking lock: %s' % (to_break,))
             try:
               os.remove(to_break)
             except OSError as ex:
               self.Print('FAILED to break lock: %s: %s' % (to_break, ex))
               raise
 
 
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
+    ### Section 0: Sanity checks.
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     self._CheckMinVersion("1.6.6")
 
-    # If a dependency is not pinned, track the default remote branch.
-    default_rev = 'refs/remotes/%s/master' % self.remote
-    url, deps_revision = gclient_utils.SplitUrlRevision(self.url)
-    revision = deps_revision
-    managed = True
+    ### Section 1: Handling basic options and parsing revision.
+    # Command line options trump DEPS-file pins. If neither is provided,
+    # fall back to the default branch (master).
+    # Throughout this function, 'revision' is assumed to be available on the
+    # remote; i.e. it will never be "refs/remotes/foo/bar". When it is necessary
+    # to translate the desired revision into a locally-available refish, that
+    # is handled later.
+    default_ref = 'refs/heads/master'
+    url, revision = gclient_utils.SplitUrlRevision(self.url)
     if options.revision:
-      # Override the revision number.
       revision = str(options.revision)
-    if revision == 'unmanaged':
-      # Check again for a revision in case an initial ref was specified
-      # in the url, for example bla.git@refs/heads/custombranch
-      revision = deps_revision
-      managed = False
     if not revision:
-      revision = default_rev
+      revision = default_ref
 
+    managed = (revision == 'unmanaged')
     if managed:
       self._DisableHooks()
 
     printed_path = False
     verbose = []
     if options.verbose:
+      verbose = ['--verbose']
       self.Print('_____ %s at %s' % (self.relpath, revision), timestamp=False)
-      verbose = ['--verbose']
       printed_path = True
 
-    remote_ref = scm.GIT.RefToRemoteRef(revision, self.remote)
-    if remote_ref:
-      # Rewrite remote refs to their local equivalents.
-      revision = ''.join(remote_ref)
-      rev_type = "branch"
-    elif revision.startswith('refs/'):
-      # Local branch? We probably don't want to support, since DEPS should
-      # always specify branches as they are in the upstream repo.
-      rev_type = "branch"
-    else:
-      # hash is also a tag, only make a distinction at checkout
-      rev_type = "hash"
-
     mirror = self._GetMirror(url, options)
     if mirror:
       url = mirror.mirror_path
 
-    # If we are going to introduce a new project, there is a possibility that
-    # we are syncing back to a state where the project was originally a
-    # sub-project rolled by DEPS (realistic case: crossing the Blink merge point
-    # syncing backwards, when Blink was a DEPS entry and not part of src.git).
-    # In such case, we might have a backup of the former .git folder, which can
-    # be used to avoid re-fetching the entire repo again (useful for bisects).
-    backup_dir = self.GetGitBackupDirPath()
-    target_dir = os.path.join(self.checkout_path, '.git')
-    if os.path.exists(backup_dir) and not os.path.exists(target_dir):
-      gclient_utils.safe_makedirs(self.checkout_path)
-      os.rename(backup_dir, target_dir)
+    ### Section 2: Ensuring a checkout exists at all.
+    # If our checkout path isn't a git repository, or if the repository which
+    # is there is corrupt, we need to bootstrap it.
+    needs_bootstrap = False
+    if not os.path.exists(self.checkout_path):
+      needs_boostrap = True
+    elif not os.path.exists(os.path.join(self.checkout_path, '.git')):
+      needs_bootstrap = True
+    else:
+      try:
+        self._Capture(['rev-list', '-n', '1', 'HEAD'])
+      except subprocess2.CalledProcessError as e:
+        if 'fatal: bad object HEAD' in e.stderr:
+          needs_bootstrap = True
+          # If a cache_dir is configured, that's likely why the repo is
+          # corrupt, so provide a helpful message.
+          if self.cache_dir and self.cache_dir in url:
+            self.Print(
+                'Likely due to DEPS change with git cache_dir, '
+                'the current commit points to no longer existing object.\n'
+                '%s' % e)
+
+    if needs_bootstrap:
+      # Get anything that might be there out of the way, just in case.
+      self._DeleteOrMove(options.force)
+
+      # If we are going to introduce a new project, there is a possibility that
+      # we are syncing back to a state where the project was originally
+      # a sub-project rolled by DEPS (realistic case: crossing the Blink merge
+      # point syncing backwards, when Blink was a DEPS entry and not part of
+      # src.git). In such case, we might have a backup of the former .git
+      # folder, which can be used to avoid re-fetching the entire repo again.
+      backup_dir = self.GetGitBackupDirPath()
+      if os.path.exists(backup_dir):
+        gclient_utils.safe_makedirs(self.checkout_path)
+        gclient_utils.safe_rename(backup_dir, target_dir)
+      else:
+        if mirror:
+          self._UpdateMirror(mirror, options)
+        self._Clone(revision, url, options)
+
       # Reset to a clean state
       self._Run(['reset', '--hard', 'HEAD'], options)
 
-    if (not os.path.exists(self.checkout_path) or
-        (os.path.isdir(self.checkout_path) and
-         not os.path.exists(os.path.join(self.checkout_path, '.git')))):
-      if mirror:
-        self._UpdateMirror(mirror, options)
-      try:
-        self._Clone(revision, url, options)
-      except subprocess2.CalledProcessError:
-        self._DeleteOrMove(options.force)
-        self._Clone(revision, url, options)
       if file_list is not None:
         files = self._Capture(['ls-files']).splitlines()
         file_list.extend([os.path.join(self.checkout_path, f) for f in files])
-      if not verbose:
-        # Make the output a little prettier. It's nice to have some whitespace
-        # between projects when cloning.
-        self.Print('')
-      return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
+    ### Section 3: Getting the checkout ready to be updated.
     if not managed:
-      self._UpdateBranchHeads(options, fetch=False)
       self.Print('________ unmanaged solution; skipping %s' % self.relpath)
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
-    self._maybe_break_locks(options)
+    self._MaybeBreakLocks(options)
 
-    if mirror:
-      self._UpdateMirror(mirror, options)
-
+    # TODO(agable): The logic here is pretty crazy. Clean it up.
     # See if the url has changed (the unittests use git://foo for the url, let
     # that through).
     current_url = self._Capture(['config', 'remote.%s.url' % self.remote])
-    return_early = False
     # TODO(maruel): Delete url != 'git://foo' since it's just to make the
     # unit test pass. (and update the comment above)
     # Skip url auto-correction if remote.origin.gclient-auto-fix-url is set.
     # This allows devs to use experimental repos which have a different url
     # but whose branch(s) are the same as official repos.
     if (current_url.rstrip('/') != url.rstrip('/') and
         url != 'git://foo' and
         subprocess2.capture(
             ['git', 'config', 'remote.%s.gclient-auto-fix-url' % self.remote],
             cwd=self.checkout_path).strip() != 'False'):
       self.Print('_____ switching %s to a new upstream' % self.relpath)
       if not (options.force or options.reset):
         # Make sure it's clean
         self._CheckClean(revision)
       # Switch over to the new upstream
       self._Run(['remote', 'set-url', self.remote, url], options)
       if mirror:
         with open(os.path.join(
             self.checkout_path, '.git', 'objects', 'info', 'alternates'),
             'w') as fh:
           fh.write(os.path.join(url, 'objects'))
-      self._EnsureValidHeadObjectOrCheckout(revision, options, url)
-      self._FetchAndReset(revision, file_list, options)
 
-      return_early = True
-    else:
-      self._EnsureValidHeadObjectOrCheckout(revision, options, url)
+    # If the user wants to set up refs/branch-heads/* and refs/tags/*, oblige.
+    self._ConfigBranchHeads(options)
 
-    if return_early:
+    try:
+      self._CheckClean(revision)
+    except gclient_utils.Error:
+      if options.reset:
+        self._Run(['reset', '--hard', 'HEAD'], options)
+      else:
+        raise
+
+    ### Section 4: Ensuring the desired revision is available.
+    # If the desired revision is already checked out, we have no work to do.
+    try:
+      revision_hash = self._Capture(['rev-parse', revision])
+      current_hash = self._Capture(['rev-parse', 'HEAD'])
+      if revision_hash == current_hash:
+        return self._Capture(['rev-parse', '--verify', 'HEAD'])
+    except subprocess2.CalledProcessError:
+      # We know HEAD is reachable, because if it wasn't we did the bootstrap.
+      # But if the desired revision isn't reachable, it's clearly not checked
+      # out, so continue to the rest of the routine.
+      pass
+
+    # Perform a basic fetch to see if the desired revision shows up.
+    if mirror:
+      self._UpdateMirror(mirror, options)
+    self._Fetch(options)
+    revision_hash = self._Capture(['rev-parse', revision])
+    if not gclient_utils.IsGitSha(revision_hash):
+      # If it didn't exist, fetch just that ref and save the FETCH_HEAD.
+      try:
+        revision_hash = self._Fetch(options, refspec=[revision])
+      except subprocess2.CalledProcessError as e:
+        raise gclient_utils.Error(
+            '\n____ %s at %s\n\n'
+            'The given revision is neither reachable from a normal clone,\n'
+            'nor directly fetchable from the remote. Aborting.\n'
+            % (self.relpath, revision))
+
+    ### Section 5: Performing the checkout.
+    cur_branch = self._GetCurrentBranch()
+
+    if cur_branch is None:
+      # We're in a detached HEAD state. Ensure the current commit is reachable
+      # (by creating a new branch if necessary), and then check out the new one.
+      self._CheckDetachedHead(revision, options)
+      # 'git checkout' may need to overwrite existing untracked files. Allow
+      # it only when nuclear options are enabled.
+      self._Checkout(
+          options,
+          revision,
+          force=(options.force and options.delete_unversioned_trees),
+          quiet=True,
+      )
+      if not printed_path:
+        self.Print('_____ %s at %s' % (self.relpath, revision), timestamp=False)
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
-    cur_branch = self._GetCurrentBranch()
-
+    # TODO(agable): Drastically simplify this. I think it can be reduced to
+    # * Only rebase if --auto_rebase is passed
+    # * If rebase fails, and --force is passed, just switch
+    # * If rebase fails, and --force is not passed, abort
+    # * If not told to rebase, just switch
+    # But not reducing it yet, because I'm scared of breaking too much at once.
     # Cases:
     # 0) HEAD is detached. Probably from our initial clone.
     #   - make sure HEAD is contained by a named ref, then update.
     # Cases 1-4. HEAD is a branch.
     # 1) current branch is not tracking a remote branch
     #   - try to rebase onto the new hash or branch
     # 2) current branch is tracking a remote branch with local committed
     #    changes, but the DEPS file switched to point to a hash
     #   - rebase those changes on top of the hash
     # 3) current branch is tracking a remote branch w/or w/out changes, and
     #    no DEPS switch
     #   - see if we can FF, if not, prompt the user for rebase, merge, or stop
     # 4) current branch is tracking a remote branch, but DEPS switches to a
     #    different remote branch, and
     #   a) current branch has no local changes, and --force:
     #      - checkout new branch
     #   b) current branch has local changes, and --force and --reset:
     #      - checkout new branch
     #   c) otherwise exit
 
-    # GetUpstreamBranch returns something like 'refs/remotes/origin/master' for
-    # a tracking branch
+    # GetUpstreamBranch returns something like 'refs/remotes/origin/master'
+    # for a tracking branch
     # or 'master' if not a tracking branch (it's based on a specific rev/hash)
     # or it returns None if it couldn't find an upstream
-    if cur_branch is None:
-      upstream_branch = None
-      current_type = "detached"
-      logging.debug("Detached HEAD")
+    upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
+    if not upstream_branch or not upstream_branch.startswith('refs/remotes'):
+      current_type = "hash"
+      logging.debug("Current branch is not tracking an upstream (remote)"
+                    " branch.")
+    elif upstream_branch.startswith('refs/remotes'):
+      current_type = "branch"
     else:
-      upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
-      if not upstream_branch or not upstream_branch.startswith('refs/remotes'):
-        current_type = "hash"
-        logging.debug("Current branch is not tracking an upstream (remote)"
-                      " branch.")
-      elif upstream_branch.startswith('refs/remotes'):
-        current_type = "branch"
-      else:
-        raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
-
-    if not scm.GIT.IsValidRevision(self.checkout_path, revision, sha_only=True):
-      # Update the remotes first so we have all the refs.
-      remote_output = scm.GIT.Capture(['remote'] + verbose + ['update'],
-              cwd=self.checkout_path)
-      if verbose:
-        self.Print(remote_output)
-
-    self._UpdateBranchHeads(options, fetch=True)
+      raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       target = 'HEAD'
       if options.upstream and upstream_branch:
         target = upstream_branch
       self._Run(['reset', '--hard', target], options)
 
     if current_type == 'detached':
       # case 0
@@ skipping 130 matching lines @@
           self.Print(merge_output.strip())
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
             self.Print('')
 
       if file_list is not None:
         file_list.extend(
             [os.path.join(self.checkout_path, f) for f in rebase_files])
 
-    # If the rebase generated a conflict, abort and ask user to fix
+    ### Section 6: Final cleanup.
+    # If the rebase generated a conflict, abort and ask user to fix.
     if self._IsRebasing():
       raise gclient_utils.Error('\n____ %s at %s\n'
                                 '\nConflict while rebasing this branch.\n'
                                 'Fix the conflict and run gclient again.\n'
                                 'See man git-rebase for details.\n'
                                 % (self.relpath, revision))
 
     if verbose:
       self.Print('Checked out revision %s' % self.revinfo(options, (), None),
                  timestamp=False)
@@ skipping 148 matching lines @@
         depth = 10000
     else:
       depth = None
     mirror.populate(verbose=options.verbose,
                     bootstrap=not getattr(options, 'no_bootstrap', False),
                     depth=depth,
                     ignore_lock=getattr(options, 'ignore_locks', False),
                     lock_timeout=getattr(options, 'lock_timeout', 0))
     mirror.unlock()
 
-  def _Clone(self, revision, url, options):
-    """Clone a git repository from the given URL.
+  def _Clone(self, url, options):
+    """Perform a bare clone a git repository from the given URL.
 
-    Once we've cloned the repo, we checkout a working branch if the specified
-    revision is a branch head. If it is a tag or a specific commit, then we
-    leave HEAD detached as it makes future updates simpler -- in this case the
-    user should first create a new branch or switch to an existing branch before
-    making changes in the repo."""
+    Does not perform any checkout. Only fetches the default set of refs that
+    a normal clone would get, and does not set up any custom fetch specs.
+    """
     if not options.verbose:
       # git clone doesn't seem to insert a newline properly before printing
       # to stdout
       self.Print('')
+
     cfg = gclient_utils.DefaultIndexPackConfig(url)
     clone_cmd = cfg + ['clone', '--no-checkout', '--progress']
     if self.cache_dir:
       clone_cmd.append('--shared')
     if options.verbose:
       clone_cmd.append('--verbose')
     clone_cmd.append(url)
     # If the parent directory does not exist, Git clone on Windows will not
     # create it, so we need to do it manually.
     parent_dir = os.path.dirname(self.checkout_path)
@@ skipping 13 matching lines @@
         with open(os.path.join(template_dir, 'shallow'), 'w') as template_file:
           template_file.write(revision)
         clone_cmd.append('--template=' + template_dir)
       else:
         # Otherwise, we're just interested in the HEAD. Just use --depth.
         clone_cmd.append('--depth=1')
 
     tmp_dir = tempfile.mkdtemp(
         prefix='_gclient_%s_' % os.path.basename(self.checkout_path),
         dir=parent_dir)
+
     try:
       clone_cmd.append(tmp_dir)
       self._Run(clone_cmd, options, cwd=self._root_dir, retry=True)
       gclient_utils.safe_makedirs(self.checkout_path)
       gclient_utils.safe_rename(os.path.join(tmp_dir, '.git'),
                                 os.path.join(self.checkout_path, '.git'))
     except:
       traceback.print_exc(file=self.out_fh)
       raise
     finally:
       if os.listdir(tmp_dir):
         self.Print('_____ removing non-empty tmp dir %s' % tmp_dir)
       gclient_utils.rmtree(tmp_dir)
       if template_dir:
         gclient_utils.rmtree(template_dir)
-    self._UpdateBranchHeads(options, fetch=True)
-    remote_ref = scm.GIT.RefToRemoteRef(revision, self.remote)
-    self._Checkout(options, ''.join(remote_ref or revision), quiet=True)
-    if self._GetCurrentBranch() is None:
-      # Squelch git's very verbose detached HEAD warning and use our own
-      self.Print(
-        ('Checked out %s to a detached HEAD. Before making any commits\n'
-         'in this repo, you should use \'git checkout <branch>\' to switch to\n'
-         'an existing branch or use \'git checkout %s -b <branch>\' to\n'
-         'create a new branch for your work.') % (revision, self.remote))
+
+    if not verbose:
+      # Make the output a little prettier. It's nice to have some whitespace
+      # between projects when cloning.
+      self.Print('')
 
   def _AskForData(self, prompt, options):
     if options.jobs > 1:
       self.Print(prompt)
       raise gclient_utils.Error("Background task requires input. Rerun "
                                 "gclient with --jobs=1 so that\n"
                                 "interaction is possible.")
     try:
       return raw_input(prompt)
     except KeyboardInterrupt:
       # Hide the exception.
       sys.exit(1)
 
-
   def _AttemptRebase(self, upstream, files, options, newbase=None,
                      branch=None, printed_path=False, merge=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     if files is not None:
       files.extend(self._Capture(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     action = 'merge' if merge else 'rebase'
     if not printed_path:
@@ skipping 65 matching lines @@
       # whitespace between projects when syncing.
       self.Print('')
 
   @staticmethod
   def _CheckMinVersion(min_version):
     (ok, current_version) = scm.GIT.AssertVersion(min_version)
     if not ok:
       raise gclient_utils.Error('git version %s < minimum required %s' %
                                 (current_version, min_version))
 
-  def _EnsureValidHeadObjectOrCheckout(self, revision, options, url):
-    # Special case handling if all 3 conditions are met:
-    #   * the mirros have recently changed, but deps destination remains same,
-    #   * the git histories of mirrors are conflicting.
-    #   * git cache is used
-    # This manifests itself in current checkout having invalid HEAD commit on
-    # most git operations. Since git cache is used, just deleted the .git
-    # folder, and re-create it by cloning.
-    try:
-      self._Capture(['rev-list', '-n', '1', 'HEAD'])
-    except subprocess2.CalledProcessError as e:
-      if ('fatal: bad object HEAD' in e.stderr
-          and self.cache_dir and self.cache_dir in url):
-        self.Print((
-          'Likely due to DEPS change with git cache_dir, '
-          'the current commit points to no longer existing object.\n'
-          '%s' % e)
-        )
-        self._DeleteOrMove(options.force)
-        self._Clone(revision, url, options)
-      else:
-        raise
-
   def _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
     # have a plumbing command to determine whether a rebase is in progress, so
     # for now emualate (more-or-less) git-rebase.sh / git-completion.bash
     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, revision):
@@ skipping 74 matching lines @@
     if quiet is None:
       quiet = (not options.verbose)
     checkout_args = ['checkout']
     if force:
       checkout_args.append('--force')
     if quiet:
       checkout_args.append('--quiet')
     checkout_args.append(ref)
     return self._Capture(checkout_args)
 
-  def _Fetch(self, options, remote=None, prune=False, quiet=False):
+  def _Fetch(
+      self, options, remote=None, refspec=None, prune=False, quiet=False):
     cfg = gclient_utils.DefaultIndexPackConfig(self.url)
+    remote = remote or self.remote
+    refspec = refspec or []
     fetch_cmd =  cfg + [
         'fetch',
-        remote or self.remote,
-    ]
+        remote,
+    ] + refspec
 
     if prune:
       fetch_cmd.append('--prune')
     if options.verbose:
       fetch_cmd.append('--verbose')
     elif quiet:
       fetch_cmd.append('--quiet')
     self._Run(fetch_cmd, options, show_header=options.verbose, retry=True)
 
     # Return the revision that was fetched; this will be stored in 'FETCH_HEAD'
     return self._Capture(['rev-parse', '--verify', 'FETCH_HEAD'])
 
-  def _UpdateBranchHeads(self, options, fetch=False):
-    """Adds, and optionally fetches, "branch-heads" and "tags" refspecs
-    if requested."""
-    need_fetch = fetch
+  def _ConfigBranchHeads(self, options):
+    """Adds "branch-heads" and "tags" refspecs if requested."""
     if hasattr(options, 'with_branch_heads') and options.with_branch_heads:
       config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/branch-heads/*:refs/remotes/branch-heads/*',
                     '^\\+refs/branch-heads/\\*:.*$']
       self._Run(config_cmd, options)
-      need_fetch = True
     if hasattr(options, 'with_tags') and options.with_tags:
       config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/tags/*:refs/tags/*',
                     '^\\+refs/tags/\\*:.*$']
       self._Run(config_cmd, options)
-      need_fetch = True
-    if fetch and need_fetch:
-      self._Fetch(options, prune=options.force)
 
   def _Run(self, args, options, show_header=True, **kwargs):
     # Disable 'unused options' warning | pylint: disable=W0613
     kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stdout', self.out_fh)
     kwargs['filter_fn'] = self.filter
     kwargs.setdefault('print_stdout', False)
     env = scm.GIT.ApplyEnvVars(kwargs)
     cmd = ['git'] + args
     if show_header:
       gclient_utils.CheckCallAndFilterAndHeader(cmd, env=env, **kwargs)
     else:
       gclient_utils.CheckCallAndFilter(cmd, env=env, **kwargs)