Revamped terminal output for update.

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 logging
 import os
 import posixpath
 import re
 import shlex
 import sys
 import tempfile
 import traceback
 import urlparse
 
@@ skipping 11 matching lines @@
 
 
 class DiffFiltererWrapper(object):
   """Simple base class which tracks which file is being diffed and
   replaces instances of its file name in the original and
   working copy lines of the svn/git diff output."""
   index_string = None
   original_prefix = "--- "
   working_prefix = "+++ "
 
-  def __init__(self, relpath):
+  def __init__(self, relpath, print_func):
     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
     self._relpath = relpath.replace("\\", "/")
     self._current_file = None
+    self._print_func = print_func
 
   def SetCurrentFile(self, current_file):
     self._current_file = current_file
 
   @property
   def _replacement_file(self):
     return posixpath.join(self._relpath, self._current_file)
 
   def _Replace(self, line):
     return line.replace(self._current_file, self._replacement_file)
 
   def Filter(self, line):
     if (line.startswith(self.index_string)):
       self.SetCurrentFile(line[len(self.index_string):])
       line = self._Replace(line)
     else:
       if (line.startswith(self.original_prefix) or
           line.startswith(self.working_prefix)):
         line = self._Replace(line)
-    print(line)
+    self._print_func(line)
 
 
 class SvnDiffFilterer(DiffFiltererWrapper):
   index_string = "Index: "
 
 
 class GitDiffFilterer(DiffFiltererWrapper):
   index_string = "diff --git "
 
   def SetCurrentFile(self, current_file):
@@ skipping 14 matching lines @@
     if (url.startswith('git://') or url.startswith('ssh://') or
         url.startswith('git+http://') or url.startswith('git+https://') or
         url.endswith('.git') or url.startswith('sso://')):
       return 'git'
     elif (url.startswith('http://') or url.startswith('https://') or
           url.startswith('svn://') or url.startswith('svn+ssh://')):
       return 'svn'
   return None
 
 
-def CreateSCM(url, root_dir=None, relpath=None):
+def CreateSCM(url, root_dir=None, relpath=None, out_fh=None, out_cb=None):
   SCM_MAP = {
     'svn' : SVNWrapper,
     'git' : GitWrapper,
   }
 
   scm_name = GetScmName(url)
   if not scm_name in SCM_MAP:
     raise gclient_utils.Error('No SCM found for url %s' % url)
   scm_class = SCM_MAP[scm_name]
   if not scm_class.BinaryExists():
     raise gclient_utils.Error('%s command not found' % scm_name)
-  return scm_class(url, root_dir, relpath)
+  return scm_class(url, root_dir, relpath, out_fh, out_cb)
 
 
 # SCMWrapper base class
 
 class SCMWrapper(object):
   """Add necessary glue between all the supported SCM.
 
   This is the abstraction layer to bind to different SCM.
   """
-  def __init__(self, url=None, root_dir=None, relpath=None):
+
+  def __init__(self, url=None, root_dir=None, relpath=None, out_fh=None,
+               out_cb=None):
     self.url = url
     self._root_dir = root_dir
     if self._root_dir:
       self._root_dir = self._root_dir.replace('/', os.sep)
     self.relpath = relpath
     if self.relpath:
       self.relpath = self.relpath.replace('/', os.sep)
     if self.relpath and self._root_dir:
       self.checkout_path = os.path.join(self._root_dir, self.relpath)
+    if out_fh is None:
+      out_fh = sys.stdout
+    self.out_fh = out_fh
+    self.out_cb = out_cb
+
+  def Print(self, *args, **kwargs):
+    kwargs.setdefault('file', self.out_fh)
+    if kwargs.pop('timestamp', True):
+      self.out_fh.write('[%s] ' % gclient_utils.Elapsed())
+    print(*args, **kwargs)
 
   def RunCommand(self, command, options, args, file_list=None):
     commands = ['cleanup', 'update', 'updatesingle', 'revert',
                 'revinfo', 'status', 'diff', 'pack', 'runhooks']
 
     if not command in commands:
       raise gclient_utils.Error('Unknown command %s' % command)
 
     if not command in dir(self):
       raise gclient_utils.Error('Command %s not implemented in %s wrapper' % (
@@ skipping 45 matching lines @@
       return False
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
   name = 'git'
   remote = 'origin'
 
   cache_dir = None
 
-  def __init__(self, url=None, root_dir=None, relpath=None):
+  def __init__(self, url=None, root_dir=None, relpath=None, out_fh=None,
+               out_cb=None):
     """Removes 'git+' fake prefix from git URL."""
     if url.startswith('git+http://') or url.startswith('git+https://'):
       url = url[4:]
-    SCMWrapper.__init__(self, url, root_dir, relpath)
+    SCMWrapper.__init__(self, url, root_dir, relpath, out_fh, out_cb)
 
   @staticmethod
   def BinaryExists():
     """Returns true if the command exists."""
     try:
       # We assume git is newer than 1.7.  See: crbug.com/114483
       result, version = scm.GIT.AssertVersion('1.7')
       if not result:
         raise gclient_utils.Error('Git version is older than 1.7: %s' % version)
       return result
@@ skipping 25 matching lines @@
     """Generates a patch file which can be applied to the root of the
     repository.
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
     merge_base = self._Capture(['merge-base', 'HEAD', self.remote])
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff', merge_base],
         cwd=self.checkout_path,
-        filter_fn=GitDiffFilterer(self.relpath).Filter)
+        filter_fn=GitDiffFilterer(self.relpath).Filter, print_func=self.Print)
 
   def UpdateSubmoduleConfig(self):
     submod_cmd = ['git', 'config', '-f', '$toplevel/.git/config',
                   'submodule.$name.ignore', 'all']
     cmd = ['git', 'submodule', '--quiet', 'foreach', ' '.join(submod_cmd)]
     cmd2 = ['git', 'config', 'diff.ignoreSubmodules', 'all']
     cmd3 = ['git', 'config', 'branch.autosetupmerge']
     cmd4 = ['git', 'config', 'fetch.recurseSubmodules', 'false']
     kwargs = {'cwd': self.checkout_path,
               'print_stdout': False,
@@ skipping 54 matching lines @@
       revision = None
       managed = False
     if not revision:
       revision = default_rev
 
     if gclient_utils.IsDateRevision(revision):
       # Date-revisions only work on git-repositories if the reflog hasn't
       # expired yet. Use rev-list to get the corresponding revision.
       #  git rev-list -n 1 --before='time-stamp' branchname
       if options.transitive:
-        print('Warning: --transitive only works for SVN repositories.')
+        self.Print('Warning: --transitive only works for SVN repositories.')
         revision = default_rev
 
     rev_str = ' at %s' % revision
     files = [] if file_list is not None else None
 
     printed_path = False
     verbose = []
     if options.verbose:
-      print('\n_____ %s%s' % (self.relpath, rev_str))
+      self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
       verbose = ['--verbose']
       printed_path = True
 
     url = self._CreateOrUpdateCache(url, options)
 
     if revision.startswith('refs/'):
       rev_type = "branch"
     elif revision.startswith(self.remote + '/'):
       # For compatibility with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace(self.remote + '/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
     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')))):
       self._Clone(revision, url, options)
       self.UpdateSubmoduleConfig()
       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.
-        print('')
+        self.Print('')
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     if not managed:
       self._UpdateBranchHeads(options, fetch=False)
       self.UpdateSubmoduleConfig()
-      print ('________ unmanaged solution; skipping %s' % self.relpath)
+      self.Print('________ unmanaged solution; skipping %s' % self.relpath)
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
                                 '\tTo resolve:\n'
                                 '\t\trm -rf %s\n'
                                 '\tAnd run gclient sync again\n'
                                 % (self.relpath, rev_str, self.relpath))
 
     # 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 != url and
         url != 'git://foo' and
         subprocess2.capture(
             ['git', 'config', 'remote.%s.gclient-auto-fix-url' % self.remote],
             cwd=self.checkout_path).strip() != 'False'):
-      print('_____ switching %s to a new upstream' % self.relpath)
+      self.Print('_____ switching %s to a new upstream' % self.relpath)
       # Make sure it's clean
       self._CheckClean(rev_str)
       # Switch over to the new upstream
       self._Run(['remote', 'set-url', self.remote, url], options)
       self._FetchAndReset(revision, file_list, options)
       return_early = True
 
     if return_early:
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
@@ skipping 32 matching lines @@
       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:
-        print(remote_output)
+        self.Print(remote_output)
 
       self._UpdateBranchHeads(options, fetch=True)
 
     # 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
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
       self._Capture(['checkout', '--quiet', '%s' % revision])
       if not printed_path:
-        print('\n_____ %s%s' % (self.relpath, rev_str))
+        self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
     elif current_type == 'hash':
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
         self._AttemptRebase(upstream_branch, files, options,
                             newbase=revision, printed_path=printed_path,
                             merge=options.merge)
         printed_path = True
       else:
         # Can't find a merge-base since we don't know our upstream. That makes
         # this command VERY likely to produce a rebase failure. For now we
         # assume origin is our upstream since that's what the old behavior was.
         upstream_branch = self.remote
         if options.revision or deps_revision:
           upstream_branch = revision
         self._AttemptRebase(upstream_branch, files, options,
                             printed_path=printed_path, merge=options.merge)
         printed_path = True
     elif rev_type == 'hash':
       # case 2
       self._AttemptRebase(upstream_branch, files, options,
                           newbase=revision, printed_path=printed_path,
                           merge=options.merge)
       printed_path = True
     elif revision.replace('heads', 'remotes/' + self.remote) != upstream_branch:
       # case 4
       new_base = revision.replace('heads', 'remotes/' + self.remote)
       if not printed_path:
-        print('\n_____ %s%s' % (self.relpath, rev_str))
+        self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
       switch_error = ("Switching upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please merge or rebase manually:\n" +
                      "cd %s; git rebase %s\n" % (self.checkout_path, new_base) +
                      "OR git checkout -b <some new branch> %s" % new_base)
       raise gclient_utils.Error(switch_error)
     else:
       # case 3 - the default case
       if files is not None:
         files = self._Capture(['diff', upstream_branch, '--name-only']).split()
       if verbose:
-        print('Trying fast-forward merge to branch : %s' % upstream_branch)
+        self.Print('Trying fast-forward merge to branch : %s' % upstream_branch)
       try:
         merge_args = ['merge']
         if options.merge:
           merge_args.append('--ff')
         else:
           merge_args.append('--ff-only')
         merge_args.append(upstream_branch)
-        merge_output = scm.GIT.Capture(merge_args, cwd=self.checkout_path)
+        merge_output = self._Capture(merge_args)
       except subprocess2.CalledProcessError as e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           files = []
           if not printed_path:
-            print('\n_____ %s%s' % (self.relpath, rev_str))
+            self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
             printed_path = True
           while True:
             try:
               action = self._AskForData(
                   'Cannot %s, attempt to rebase? '
                   '(y)es / (q)uit / (s)kip : ' %
                       ('merge' if options.merge else 'fast-forward merge'),
                   options)
             except ValueError:
               raise gclient_utils.Error('Invalid Character')
             if re.match(r'yes|y', action, re.I):
               self._AttemptRebase(upstream_branch, files, options,
                                   printed_path=printed_path, merge=False)
               printed_path = True
               break
             elif re.match(r'quit|q', action, re.I):
               raise gclient_utils.Error("Can't fast-forward, please merge or "
                                         "rebase manually.\n"
                                         "cd %s && git " % self.checkout_path
                                         + "rebase %s" % upstream_branch)
             elif re.match(r'skip|s', action, re.I):
-              print('Skipping %s' % self.relpath)
+              self.Print('Skipping %s' % self.relpath)
               return
             else:
-              print('Input not recognized')
+              self.Print('Input not recognized')
         elif re.match("error: Your local changes to '.*' would be "
                       "overwritten by merge.  Aborting.\nPlease, commit your "
                       "changes or stash them before you can merge.\n",
                       e.stderr):
           if not printed_path:
-            print('\n_____ %s%s' % (self.relpath, rev_str))
+            self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
             printed_path = True
           raise gclient_utils.Error(e.stderr)
         else:
           # Some other problem happened with the merge
           logging.error("Error during fast-forward merge in %s!" % self.relpath)
-          print(e.stderr)
+          self.Print(e.stderr)
           raise
       else:
         # Fast-forward merge was successful
         if not re.match('Already up-to-date.', merge_output) or verbose:
           if not printed_path:
-            print('\n_____ %s%s' % (self.relpath, rev_str))
+            self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
             printed_path = True
-          print(merge_output.strip())
+          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.
-            print('')
+            self.Print('')
 
     self.UpdateSubmoduleConfig()
     if file_list is not None:
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
     # If the rebase generated a conflict, abort and ask user to fix
     if self._IsRebasing():
       raise gclient_utils.Error('\n____ %s%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, rev_str))
 
     if verbose:
-      print('Checked out revision %s' % self.revinfo(options, (), None))
+      self.Print('Checked out revision %s' % self.revinfo(options, (), None),
+                 timestamp=False)
 
     # If --reset and --delete_unversioned_trees are specified, remove any
     # untracked directories.
     if options.reset and options.delete_unversioned_trees:
       # GIT.CaptureStatus() uses 'dit diff' to compare to a specific SHA1 (the
       # merge-base by default), so doesn't include untracked files. So we use
       # 'git ls-files --directory --others --exclude-standard' here directly.
       paths = scm.GIT.Capture(
           ['ls-files', '--directory', '--others', '--exclude-standard'],
           self.checkout_path)
       for path in (p for p in paths.splitlines() if p.endswith('/')):
         full_path = os.path.join(self.checkout_path, path)
         if not os.path.islink(full_path):
-          print('\n_____ removing unversioned directory %s' % path)
+          self.Print('_____ removing unversioned directory %s' % path)
           gclient_utils.rmtree(full_path)
 
     return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
 
   def revert(self, options, _args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
     if not os.path.isdir(self.checkout_path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      print('\n_____ %s is missing, synching instead' % self.relpath)
+      self.Print('_____ %s is missing, synching instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     if options.upstream:
       if self._GetCurrentBranch():
         upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
         default_rev = upstream_branch or default_rev
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
@@ skipping 14 matching lines @@
   def revinfo(self, _options, _args, _file_list):
     """Returns revision"""
     return self._Capture(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, _args, file_list):
     """Display status information."""
     if not os.path.isdir(self.checkout_path):
-      print(('\n________ couldn\'t run status in %s:\n'
-             'The directory does not exist.') % self.checkout_path)
+      self.Print('________ couldn\'t run status in %s:\n'
+                 'The directory does not exist.' % self.checkout_path)
     else:
       merge_base = self._Capture(['merge-base', 'HEAD', self.remote])
-      self._Run(['diff', '--name-status', merge_base], options)
+      self._Run(['diff', '--name-status', merge_base], options,
+                stdout=self.out_fh)
       if file_list is not None:
         files = self._Capture(['diff', '--name-only', merge_base]).split()
         file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def GetUsableRev(self, rev, options):
     """Finds a useful revision for this repository.
 
     If SCM is git-svn and the head revision is less than |rev|, git svn fetch
     will be called on the source."""
     sha1 = None
@@ skipping 13 matching lines @@
         if not local_head or local_head < int(rev):
           try:
             logging.debug('Looking for git-svn configuration optimizations.')
             if scm.GIT.Capture(['config', '--get', 'svn-remote.svn.fetch'],
                              cwd=self.checkout_path):
               scm.GIT.Capture(['fetch'], cwd=self.checkout_path)
           except subprocess2.CalledProcessError:
             logging.debug('git config --get svn-remote.svn.fetch failed, '
                           'ignoring possible optimization.')
           if options.verbose:
-            print('Running git svn fetch. This might take a while.\n')
+            self.Print('Running git svn fetch. This might take a while.\n')
           scm.GIT.Capture(['svn', 'fetch'], cwd=self.checkout_path)
         try:
           sha1 = scm.GIT.GetBlessedSha1ForSvnRev(
               cwd=self.checkout_path, rev=rev)
         except gclient_utils.Error, e:
           sha1 = e.message
-          print('\nWarning: Could not find a git revision with accurate\n'
+          self.Print('Warning: Could not find a git revision with accurate\n'
                  '.DEPS.git that maps to SVN revision %s.  Sync-ing to\n'
                  'the closest sane git revision, which is:\n'
                  '  %s\n' % (rev, e.message))
         if not sha1:
           raise gclient_utils.Error(
               ( 'It appears that either your git-svn remote is incorrectly\n'
                 'configured or the revision in your safesync_url is\n'
                 'higher than git-svn remote\'s HEAD as we couldn\'t find a\n'
                 'corresponding git hash for SVN rev %s.' ) % rev)
     else:
@@ skipping 41 matching lines @@
     """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."""
     if not options.verbose:
       # git clone doesn't seem to insert a newline properly before printing
       # to stdout
-      print('')
+      self.Print('')
     template_path = os.path.join(
         os.path.dirname(THIS_FILE_PATH), 'git-templates')
     cfg = gclient_utils.DefaultIndexPackConfig(self.url)
     clone_cmd = cfg + [
         'clone', '--no-checkout', '--progress', '--template=%s' % template_path]
     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)
     gclient_utils.safe_makedirs(parent_dir)
     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=sys.stderr)
+      traceback.print_exc(file=self.out_fh)
       raise
     finally:
       if os.listdir(tmp_dir):
-        print('\n_____ removing non-empty tmp dir %s' % tmp_dir)
+        self.Print('_____ removing non-empty tmp dir %s' % tmp_dir)
       gclient_utils.rmtree(tmp_dir)
     if revision.startswith('refs/heads/'):
       self._Run(
           ['checkout', '--quiet', revision.replace('refs/heads/', '')], options)
     else:
       # Squelch git's very verbose detached HEAD warning and use our own
       self._Run(['checkout', '--quiet', revision], options)
-      print(
+      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))
 
   @staticmethod
   def _AskForData(prompt, options):
     if options.jobs > 1:
       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:
-      print('\n_____ %s : Attempting %s onto %s...' % (
+      self.Print('_____ %s : Attempting %s onto %s...' % (
           self.relpath, action, revision))
       printed_path = True
     else:
-      print('Attempting %s onto %s...' % (action, revision))
+      self.Print('Attempting %s onto %s...' % (action, revision))
 
     if merge:
       merge_output = self._Capture(['merge', revision])
       if options.verbose:
-        print(merge_output)
+        self.Print(merge_output)
       return
 
     # Build the rebase command here using the args
     # git rebase [options] [--onto <newbase>] <upstream> [<branch>]
     rebase_cmd = ['rebase']
     if options.verbose:
       rebase_cmd.append('--verbose')
     if newbase:
       rebase_cmd.extend(['--onto', newbase])
     rebase_cmd.append(upstream)
@@ skipping 15 matching lines @@
           if re.match(r'yes|y', rebase_action, re.I):
             self._Run(['reset', '--hard', 'HEAD'], options)
             # Should this be recursive?
             rebase_output = scm.GIT.Capture(rebase_cmd, cwd=self.checkout_path)
             break
           elif re.match(r'quit|q', rebase_action, re.I):
             raise gclient_utils.Error("Please merge or rebase manually\n"
                                       "cd %s && git " % self.checkout_path
                                       + "%s" % ' '.join(rebase_cmd))
           elif re.match(r'show|s', rebase_action, re.I):
-            print('\n%s' % e.stderr.strip())
+            self.Print('%s' % e.stderr.strip())
             continue
           else:
             gclient_utils.Error("Input not recognized")
             continue
       elif re.search(r'^CONFLICT', e.stdout, re.M):
         raise gclient_utils.Error("Conflict while rebasing this branch.\n"
                                   "Fix the conflict and run gclient again.\n"
                                   "See 'man git-rebase' for details.\n")
       else:
-        print(e.stdout.strip())
-        print('Rebase produced error output:\n%s' % e.stderr.strip())
+        self.Print(e.stdout.strip())
+        self.Print('Rebase produced error output:\n%s' % e.stderr.strip())
         raise gclient_utils.Error("Unrecognized error, please merge or rebase "
                                   "manually.\ncd %s && git " %
                                   self.checkout_path
                                   + "%s" % ' '.join(rebase_cmd))
 
-    print(rebase_output.strip())
+    self.Print(rebase_output.strip())
     if not options.verbose:
       # Make the output a little prettier. It's nice to have some
       # whitespace between projects when syncing.
-      print('')
+      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 _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
@@ skipping 38 matching lines @@
         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', '-f', name])
-      print('\n_____ found an unreferenced commit and saved it as \'%s\'' %
+      self.Print('_____ 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, cwd=None):
-    return subprocess2.check_output(
-        ['git'] + args,
-        stderr=subprocess2.VOID,
-        cwd=cwd or self.checkout_path).strip()
+  def _Capture(self, args, cwd=None, **kwargs):
+    kwargs.setdefault('cwd', self.checkout_path)
+    kwargs.setdefault('stderr', subprocess2.PIPE)
+    return subprocess2.check_output(['git'] + args, **kwargs).strip()
 
   def _UpdateBranchHeads(self, options, fetch=False):
     """Adds, and optionally fetches, "branch-heads" 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)
       if fetch:
         cfg = gclient_utils.DefaultIndexPackConfig(self.url)
         fetch_cmd =  cfg + ['fetch', self.remote]
         if options.verbose:
           fetch_cmd.append('--verbose')
         self._Run(fetch_cmd, options, retry=True)
 
   def _Run(self, args, options, **kwargs):
-    kwargs.setdefault('cwd', self.checkout_path)
-    git_filter = not options.verbose
-    if git_filter:
-      kwargs['filter_fn'] = gclient_utils.GitFilter(kwargs.get('filter_fn'))
-      kwargs.setdefault('print_stdout', False)
-      # Don't prompt for passwords; just fail quickly and noisily.
-      # By default, git will use an interactive terminal prompt when a username/
-      # password is needed.  That shouldn't happen in the chromium workflow,
-      # and if it does, then gclient may hide the prompt in the midst of a flood
-      # of terminal spew.  The only indication that something has gone wrong
-      # will be when gclient hangs unresponsively.  Instead, we disable the
-      # password prompt and simply allow git to fail noisily.  The error
-      # message produced by git will be copied to gclient's output.
-      env = kwargs.get('env') or kwargs.setdefault('env', os.environ.copy())
-      env.setdefault('GIT_ASKPASS', 'true')
-      env.setdefault('SSH_ASKPASS', 'true')
-    else:
-      kwargs.setdefault('print_stdout', True)
+    cwd = kwargs.setdefault('cwd', self.checkout_path)
+    kwargs.setdefault('stdout', self.out_fh)
+    filter_kwargs = { 'time_throttle': 10, 'out_fh': self.out_fh }
+    if self.out_cb:
+      filter_kwargs['predicate'] = self.out_cb
+    kwargs['filter_fn'] = git_filter = gclient_utils.GitFilter(**filter_kwargs)
+    kwargs.setdefault('print_stdout', False)
+    # Don't prompt for passwords; just fail quickly and noisily.
+    # By default, git will use an interactive terminal prompt when a username/
+    # password is needed.  That shouldn't happen in the chromium workflow,
+    # and if it does, then gclient may hide the prompt in the midst of a flood
+    # of terminal spew.  The only indication that something has gone wrong
+    # will be when gclient hangs unresponsively.  Instead, we disable the
+    # password prompt and simply allow git to fail noisily.  The error
+    # message produced by git will be copied to gclient's output.
+    env = kwargs.get('env') or kwargs.setdefault('env', os.environ.copy())
+    env.setdefault('GIT_ASKPASS', 'true')
+    env.setdefault('SSH_ASKPASS', 'true')
+
     cmd = ['git'] + args
-    return gclient_utils.CheckCallAndFilterAndHeader(cmd, **kwargs)
+    header = "running '%s' in '%s'" % (' '.join(cmd), cwd)
+    git_filter(header)
+    return gclient_utils.CheckCallAndFilter(cmd, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
   name = 'svn'
 
   @staticmethod
   def BinaryExists():
     """Returns true if the command exists."""
     try:
@@ skipping 29 matching lines @@
   def pack(self, _options, args, _file_list):
     """Generates a patch file which can be applied to the root of the
     repository."""
     if not os.path.isdir(self.checkout_path):
       raise gclient_utils.Error('Directory %s is not present.' %
           self.checkout_path)
     gclient_utils.CheckCallAndFilter(
         ['svn', 'diff', '-x', '--ignore-eol-style'] + args,
         cwd=self.checkout_path,
         print_stdout=False,
-        filter_fn=SvnDiffFilterer(self.relpath).Filter)
+        filter_fn=SvnDiffFilterer(self.relpath).Filter, print_func=self.Print)
 
   def update(self, options, args, file_list):
     """Runs svn 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.
     """
     # Only update if git or hg is not controlling the directory.
     git_path = os.path.join(self.checkout_path, '.git')
     if os.path.exists(git_path):
-      print('________ found .git directory; skipping %s' % self.relpath)
+      self.Print('________ found .git directory; skipping %s' % self.relpath)
       return
 
     hg_path = os.path.join(self.checkout_path, '.hg')
     if os.path.exists(hg_path):
-      print('________ found .hg directory; skipping %s' % self.relpath)
+      self.Print('________ found .hg directory; skipping %s' % self.relpath)
       return
 
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     # revision is the revision to match. It is None if no revision is specified,
     # i.e. the 'deps ain't pinned'.
     url, revision = gclient_utils.SplitUrlRevision(self.url)
     # Keep the original unpinned url for reference in case the repo is switched.
     base_url = url
@@ skipping 15 matching lines @@
       rev_str = ''
 
     # Get the existing scm url and the revision number of the current checkout.
     exists = os.path.exists(self.checkout_path)
     if exists and managed:
       try:
         from_info = scm.SVN.CaptureLocalInfo(
             [], os.path.join(self.checkout_path, '.'))
       except (gclient_utils.Error, subprocess2.CalledProcessError):
         if options.reset and options.delete_unversioned_trees:
-          print 'Removing troublesome path %s' % self.checkout_path
+          self.Print('Removing troublesome path %s' % self.checkout_path)
           gclient_utils.rmtree(self.checkout_path)
           exists = False
         else:
           msg = ('Can\'t update/checkout %s if an unversioned directory is '
                  'present. Delete the directory and try again.')
           raise gclient_utils.Error(msg % self.checkout_path)
 
     BASE_URLS = {
         '/chrome/trunk/src': 'gs://chromium-svn-checkout/chrome/',
         '/blink/trunk': 'gs://chromium-svn-checkout/blink/',
@@ skipping 20 matching lines @@
           gsutil = download_from_google_storage.Gsutil(
               GSUTIL_DEFAULT_PATH, boto_path=os.devnull)
 
           gs_path = BASE_URLS[base_path]
           _, out, _ = gsutil.check_call('ls', gs_path)
           # So that we can get the most recent revision.
           sorted_items = sorted(out.splitlines())
           latest_checkout = sorted_items[-1]
 
           tempdir = tempfile.mkdtemp()
-          print 'Downloading %s...' % latest_checkout
+          self.Print('Downloading %s...' % latest_checkout)
           code, out, err = gsutil.check_call('cp', latest_checkout, tempdir)
           if code:
-            print '%s\n%s' % (out, err)
+            self.Print('%s\n%s' % (out, err))
             raise Exception()
           filename = latest_checkout.split('/')[-1]
           tarball = os.path.join(tempdir, filename)
-          print 'Unpacking into %s...' % self.checkout_path
+          self.Print('Unpacking into %s...' % self.checkout_path)
           gclient_utils.safe_makedirs(self.checkout_path)
           # TODO(hinoka): Use 7z for windows.
           cmd = ['tar', '--extract', '--ungzip',
                   '--directory', self.checkout_path,
                   '--file', tarball]
           gclient_utils.CheckCallAndFilter(
               cmd, stdout=sys.stdout, print_stdout=True)
 
-          print 'Deleting temp file'
+          self.Print('Deleting temp file')
           gclient_utils.rmtree(tempdir)
 
           # Rewrite the repository root to match.
           tarball_url = scm.SVN.CaptureLocalInfo(
               ['.'], self.checkout_path)['Repository Root']
           tarball_parsed = urlparse.urlparse(tarball_url)
           tarball_root = '%s://%s' % (tarball_parsed.scheme,
                                       tarball_parsed.netloc)
 
           if tarball_root != local_root:
-            print 'Switching repository root to %s' % local_root
+            self.Print('Switching repository root to %s' % local_root)
             self._Run(['switch', '--relocate', tarball_root,
                        local_root, self.checkout_path],
                       options)
       except Exception as e:
-        print 'We tried to get a source tarball but failed.'
-        print 'Resuming normal operations.'
-        print str(e)
+        self.Print('We tried to get a source tarball but failed.')
+        self.Print('Resuming normal operations.')
+        self.Print(str(e))
 
       gclient_utils.safe_makedirs(os.path.dirname(self.checkout_path))
       # We need to checkout.
       command = ['checkout', url, self.checkout_path]
       command = self._AddAdditionalUpdateFlags(command, options, revision)
       self._RunAndGetFileList(command, options, file_list, self._root_dir)
       return self.Svnversion()
 
     if not managed:
-      print ('________ unmanaged solution; skipping %s' % self.relpath)
+      self.Print(('________ unmanaged solution; skipping %s' % self.relpath))
       return self.Svnversion()
 
     if 'URL' not in from_info:
       raise gclient_utils.Error(
           ('gclient is confused. Couldn\'t get the url for %s.\n'
            'Try using @unmanaged.\n%s') % (
             self.checkout_path, from_info))
 
     # Look for locked directories.
     dir_info = scm.SVN.CaptureStatus(
         None, os.path.join(self.checkout_path, '.'))
     if any(d[0][2] == 'L' for d in dir_info):
       try:
         self._Run(['cleanup', self.checkout_path], options)
       except subprocess2.CalledProcessError, e:
         # Get the status again, svn cleanup may have cleaned up at least
         # something.
         dir_info = scm.SVN.CaptureStatus(
             None, os.path.join(self.checkout_path, '.'))
 
         # Try to fix the failures by removing troublesome files.
         for d in dir_info:
           if d[0][2] == 'L':
             if d[0][0] == '!' and options.force:
               # We don't pass any files/directories to CaptureStatus and set
               # cwd=self.checkout_path, so we should get relative paths here.
               assert not os.path.isabs(d[1])
               path_to_remove = os.path.normpath(
                   os.path.join(self.checkout_path, d[1]))
-              print 'Removing troublesome path %s' % path_to_remove
+              self.Print('Removing troublesome path %s' % path_to_remove)
               gclient_utils.rmtree(path_to_remove)
             else:
-              print 'Not removing troublesome path %s automatically.' % d[1]
+              self.Print(
+                  'Not removing troublesome path %s automatically.' % d[1])
               if d[0][0] == '!':
-                print 'You can pass --force to enable automatic removal.'
+                self.Print('You can pass --force to enable automatic removal.')
               raise e
 
     # Retrieve the current HEAD version because svn is slow at null updates.
     if options.manually_grab_svn_rev and not revision:
       from_info_live = scm.SVN.CaptureRemoteInfo(from_info['URL'])
       revision = str(from_info_live['Revision'])
       rev_str = ' at %s' % revision
 
     if from_info['URL'] != base_url:
       # The repository url changed, need to switch.
       try:
         to_info = scm.SVN.CaptureRemoteInfo(url)
       except (gclient_utils.Error, subprocess2.CalledProcessError):
         # The url is invalid or the server is not accessible, it's safer to bail
         # out right now.
         raise gclient_utils.Error('This url is unreachable: %s' % url)
       can_switch = ((from_info['Repository Root'] != to_info['Repository Root'])
                     and (from_info['UUID'] == to_info['UUID']))
       if can_switch:
-        print('\n_____ relocating %s to a new checkout' % self.relpath)
+        self.Print('_____ relocating %s to a new checkout' % self.relpath)
         # We have different roots, so check if we can switch --relocate.
         # Subversion only permits this if the repository UUIDs match.
         # Perform the switch --relocate, then rewrite the from_url
         # to reflect where we "are now."  (This is the same way that
         # Subversion itself handles the metadata when switch --relocate
         # is used.)  This makes the checks below for whether we
         # can update to a revision or have to switch to a different
         # branch work as expected.
         # TODO(maruel):  TEST ME !
         command = ['switch', '--relocate',
                    from_info['Repository Root'],
                    to_info['Repository Root'],
                    self.relpath]
         self._Run(command, options, cwd=self._root_dir)
         from_info['URL'] = from_info['URL'].replace(
             from_info['Repository Root'],
             to_info['Repository Root'])
       else:
         if not options.force and not options.reset:
           # Look for local modifications but ignore unversioned files.
           for status in scm.SVN.CaptureStatus(None, self.checkout_path):
             if status[0][0] != '?':
               raise gclient_utils.Error(
                   ('Can\'t switch the checkout to %s; UUID don\'t match and '
                    'there is local changes in %s. Delete the directory and '
                    'try again.') % (url, self.checkout_path))
         # Ok delete it.
-        print('\n_____ switching %s to a new checkout' % self.relpath)
+        self.Print('_____ switching %s to a new checkout' % self.relpath)
         gclient_utils.rmtree(self.checkout_path)
         # We need to checkout.
         command = ['checkout', url, self.checkout_path]
         command = self._AddAdditionalUpdateFlags(command, options, revision)
         self._RunAndGetFileList(command, options, file_list, self._root_dir)
         return self.Svnversion()
 
     # If the provided url has a revision number that matches the revision
     # number of the existing directory, then we don't need to bother updating.
     if not options.force and str(from_info['Revision']) == revision:
       if options.verbose or not forced_revision:
-        print('\n_____ %s%s' % (self.relpath, rev_str))
+        self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
     else:
       command = ['update', self.checkout_path]
       command = self._AddAdditionalUpdateFlags(command, options, revision)
       self._RunAndGetFileList(command, options, file_list, self._root_dir)
 
     # If --reset and --delete_unversioned_trees are specified, remove any
     # untracked files and directories.
     if options.reset and options.delete_unversioned_trees:
       for status in scm.SVN.CaptureStatus(None, self.checkout_path):
         full_path = os.path.join(self.checkout_path, status[1])
         if (status[0][0] == '?'
             and os.path.isdir(full_path)
             and not os.path.islink(full_path)):
-          print('\n_____ removing unversioned directory %s' % status[1])
+          self.Print('_____ removing unversioned directory %s' % status[1])
           gclient_utils.rmtree(full_path)
     return self.Svnversion()
 
   def updatesingle(self, options, args, file_list):
     filename = args.pop()
     if scm.SVN.AssertVersion("1.5")[0]:
       if not os.path.exists(os.path.join(self.checkout_path, '.svn')):
         # Create an empty checkout and then update the one file we want.  Future
         # operations will only apply to the one file we checked out.
         command = ["checkout", "--depth", "empty", self.url, self.checkout_path]
@@ skipping 22 matching lines @@
     """Reverts local modifications. Subversion specific.
 
     All reverted files will be appended to file_list, even if Subversion
     doesn't know about them.
     """
     if not os.path.isdir(self.checkout_path):
       if os.path.exists(self.checkout_path):
         gclient_utils.rmtree(self.checkout_path)
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      print('\n_____ %s is missing, synching instead' % self.relpath)
+      self.Print('_____ %s is missing, synching instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     if not os.path.isdir(os.path.join(self.checkout_path, '.svn')):
       if os.path.isdir(os.path.join(self.checkout_path, '.git')):
-        print('________ found .git directory; skipping %s' % self.relpath)
+        self.Print('________ found .git directory; skipping %s' % self.relpath)
         return
       if os.path.isdir(os.path.join(self.checkout_path, '.hg')):
-        print('________ found .hg directory; skipping %s' % self.relpath)
+        self.Print('________ found .hg directory; skipping %s' % self.relpath)
         return
       if not options.force:
         raise gclient_utils.Error('Invalid checkout path, aborting')
-      print(
+      self.Print(
           '\n_____ %s is not a valid svn checkout, synching instead' %
           self.relpath)
       gclient_utils.rmtree(self.checkout_path)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     def printcb(file_status):
       if file_list is not None:
         file_list.append(file_status[1])
       if logging.getLogger().isEnabledFor(logging.INFO):
         logging.info('%s%s' % (file_status[0], file_status[1]))
       else:
-        print(os.path.join(self.checkout_path, file_status[1]))
+        self.Print(os.path.join(self.checkout_path, file_status[1]))
     scm.SVN.Revert(self.checkout_path, callback=printcb)
 
     # Revert() may delete the directory altogether.
     if not os.path.isdir(self.checkout_path):
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     try:
       # svn revert is so broken we don't even use it. Using
       # "svn up --revision BASE" achieve the same effect.
@@ skipping 12 matching lines @@
       return None
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     command = ['status'] + args
     if not os.path.isdir(self.checkout_path):
       # svn status won't work if the directory doesn't exist.
-      print(('\n________ couldn\'t run \'%s\' in \'%s\':\n'
+      self.Print(('\n________ couldn\'t run \'%s\' in \'%s\':\n'
              'The directory does not exist.') %
                 (' '.join(command), self.checkout_path))
       # There's no file list to retrieve.
     else:
       self._RunAndGetFileList(command, options, file_list)
 
   def GetUsableRev(self, rev, _options):
     """Verifies the validity of the revision for this repository."""
     if not scm.SVN.IsValidRevision(url='%s@%s' % (self.url, rev)):
       raise gclient_utils.Error(
@@ skipping 48 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command