Remove cruft from having to do bookeeping of options.stdout.

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
 import sys
 import time
 
 import scm
 import gclient_utils
 
 
 class DiffFilterer(object):
   """Simple 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 = "Index: "
   original_prefix = "--- "
   working_prefix = "+++ "
 
-  def __init__(self, relpath, stdout):
+  def __init__(self, relpath):
     # 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 = ""
     self._replacement_file = ""
-    self._stdout = stdout
 
   def SetCurrentFile(self, current_file):
     self._current_file = current_file
     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
     self._replacement_file = posixpath.join(self._relpath, 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)
-    self._stdout.write(line + '\n')
+    print(line)
 
 
 ### SCM abstraction layer
 
 # Factory Method for SCM wrapper creation
 
 def GetScmName(url):
   if url:
     url, _ = gclient_utils.SplitUrlRevision(url)
     if (url.startswith('git://') or url.startswith('ssh://') or
@@ skipping 84 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', 'origin'])
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff', merge_base],
         cwd=self.checkout_path,
-        filter_fn=DiffFilterer(self.relpath, options.stdout).Filter,
-        stdout=options.stdout)
+        filter_fn=DiffFilterer(self.relpath).Filter)
 
   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.
     """
     if args:
@@ skipping 10 matching lines @@
       revision = str(options.revision)
     if not revision:
       revision = default_rev
 
     rev_str = ' at %s' % revision
     files = []
 
     printed_path = False
     verbose = []
     if options.verbose:
-      options.stdout.write("\n_____ %s%s\n" % (self.relpath, rev_str))
+      print('\n_____ %s%s' % (self.relpath, rev_str))
       verbose = ['--verbose']
       printed_path = True
 
     if revision.startswith('refs/heads/'):
       rev_type = "branch"
     elif revision.startswith('origin/'):
       # For compatability with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace('origin/', '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):
       self._Clone(revision, url, options)
       files = self._Capture(['ls-files']).split()
       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.
-        options.stdout.write('\n')
+        print('')
       return
 
     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))
 
@@ skipping 39 matching lines @@
     for _ in range(10):
       try:
         remote_output = scm.GIT.Capture(
             ['remote'] + verbose + ['update'],
             cwd=self.checkout_path)
         break
       except gclient_utils.CheckCallError, 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:
-          options.stdout.write(str(e) + '\n')
-          options.stdout.write('Sleeping %.1f seconds and retrying...\n' %
-                               backoff_time)
+          print(str(e))
+          print('Sleeping %.1f seconds and retrying...' % backoff_time)
           time.sleep(backoff_time)
           backoff_time *= 1.3
           continue
         raise
 
     if verbose:
-      options.stdout.write(remote_output)
+      print(remote_output.strip())
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       self._Run(['reset', '--hard', 'HEAD'], options)
 
     if current_type == 'detached':
       # case 0
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
       self._Capture(['checkout', '--quiet', '%s^0' % revision])
       if not printed_path:
-        options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
+        print('\n_____ %s%s' % (self.relpath, rev_str))
     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)
         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 = 'origin'
         if options.revision or deps_revision:
           upstream_branch = revision
         self._AttemptRebase(upstream_branch, files, options,
                             printed_path=printed_path)
         printed_path = True
     elif rev_type == 'hash':
       # case 2
       self._AttemptRebase(upstream_branch, files, options,
                           newbase=revision, printed_path=printed_path)
       printed_path = True
     elif revision.replace('heads', 'remotes/origin') != upstream_branch:
       # case 4
       new_base = revision.replace('heads', 'remotes/origin')
       if not printed_path:
-        options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
+        print('\n_____ %s%s' % (self.relpath, rev_str))
       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
       files = self._Capture(['diff', upstream_branch, '--name-only']).split()
       if verbose:
-        options.stdout.write('Trying fast-forward merge to branch : %s\n' %
-            upstream_branch)
+        print('Trying fast-forward merge to branch : %s' % upstream_branch)
       try:
         merge_output = scm.GIT.Capture(['merge', '--ff-only', upstream_branch],
             cwd=self.checkout_path)
       except gclient_utils.CheckCallError, e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           if not printed_path:
-            options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
+            print('\n_____ %s%s' % (self.relpath, rev_str))
             printed_path = True
           while True:
             try:
               # TODO(maruel): That can't work with --jobs.
               action = str(raw_input("Cannot fast-forward merge, attempt to "
                                      "rebase? (y)es / (q)uit / (s)kip : "))
             except ValueError:
               gclient_utils.Error('Invalid Character')
               continue
             if re.match(r'yes|y', action, re.I):
               self._AttemptRebase(upstream_branch, files, options,
                                   printed_path=printed_path)
               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):
-              options.stdout.write('Skipping %s\n' % self.relpath)
+              print('Skipping %s' % self.relpath)
               return
             else:
-              options.stdout.write('Input not recognized\n')
+              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:
-            options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
+            print('\n_____ %s%s' % (self.relpath, rev_str))
             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)
-          options.stdout.write(e.stderr + '\n')
+          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:
-            options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
+            print('\n_____ %s%s' % (self.relpath, rev_str))
             printed_path = True
-          options.stdout.write(merge_output)
+          print(merge_output.strip())
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
-            options.stdout.write('\n')
+            print('')
 
     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:
-      options.stdout.write('Checked out revision %s\n' %
-          self.revinfo(options, (), None))
+      print('Checked out revision %s' % self.revinfo(options, (), None))
 
   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.
-      options.stdout.write('\n_____ %s is missing, synching instead\n' %
-          self.relpath)
+      print('\n_____ %s is missing, synching instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
       deps_revision = deps_revision.replace('refs/heads/', 'origin/')
 
     files = self._Capture(['diff', deps_revision, '--name-only']).split()
     self._Run(['reset', '--hard', deps_revision], options)
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   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):
-      options.stdout.write(
-          ('\n________ couldn\'t run status in %s:\nThe directory '
-           'does not exist.\n') % self.checkout_path)
+      print(('\n________ couldn\'t run status in %s:\n'
+             'The directory does not exist.') % self.checkout_path)
     else:
       merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
       self._Run(['diff', '--name-status', merge_base], options)
       files = self._Capture(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def FullUrlForRelativeUrl(self, url):
     # Strip from last '/'
     # Equivalent to unix basename
     base_url = self.url
     return base_url[:base_url.rfind('/')] + url
 
   def _Clone(self, revision, url, options):
     """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
-      options.stdout.write('\n')
+      print('')
 
     clone_cmd = ['clone']
     if revision.startswith('refs/heads/'):
       clone_cmd.extend(['-b', revision.replace('refs/heads/', '')])
       detach_head = False
     else:
       clone_cmd.append('--no-checkout')
       detach_head = True
     if options.verbose:
       clone_cmd.append('--verbose')
     clone_cmd.extend([url, self.checkout_path])
 
     for _ in range(3):
       try:
         self._Run(clone_cmd, options, cwd=self._root_dir)
         break
       except gclient_utils.Error, e:
         # TODO(maruel): Hackish, should be fixed by moving _Run() to
         # CheckCall().
         # 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'))):
-          options.stdout.write(str(e) + '\n')
-          options.stdout.write('Retrying...\n')
+          print(str(e))
+          print('Retrying...')
           continue
         raise e
 
     if detach_head:
       # Squelch git's very verbose detached HEAD warning and use our own
       self._Capture(['checkout', '--quiet', '%s^0' % revision])
-      options.stdout.write(
+      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 origin -b <branch>\' to\n'
          'create a new branch for your work.') % revision)
 
   def _AttemptRebase(self, upstream, files, options, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     files.extend(self._Capture(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     if not printed_path:
-      options.stdout.write('\n_____ %s : Attempting rebase onto %s...\n' % (
+      print('\n_____ %s : Attempting rebase onto %s...' % (
           self.relpath, revision))
       printed_path = True
     else:
-      options.stdout.write('Attempting rebase onto %s...\n' % revision)
+      print('Attempting rebase onto %s...' % revision)
 
     # 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)
     if branch:
@@ skipping 14 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):
-            options.stdout.write('\n%s\n' % e.stderr.strip())
+            print('\n%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:
-        options.stdout.write(e.stdout.strip() + '\n')
-        options.stdout.write('Rebase produced error output:\n%s\n' %
-            e.stderr.strip())
+        print(e.stdout.strip())
+        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))
 
-    options.stdout.write(rebase_output)
+    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.
-      options.stdout.write('\n')
+      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', name])
-      options.stdout.write(
-          '\n_____ found an unreferenced commit and saved it as \'%s\'\n' %
+      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()
 
   def _Run(self, args, options, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
     gclient_utils.CheckCallAndFilterAndHeader(['git'] + args,
-        always=options.verbose, stdout=options.stdout, **kwargs)
+        always=options.verbose, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     self._Run(['cleanup'] + args, options)
 
   def diff(self, options, args, file_list):
@@ skipping 17 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=DiffFilterer(self.relpath, options.stdout).Filter,
-        stdout=options.stdout)
+        filter_fn=DiffFilterer(self.relpath).Filter)
 
   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 is not controlling the directory.
     git_path = os.path.join(self.checkout_path, '.git')
     if os.path.exists(git_path):
-      options.stdout.write('________ found .git directory; skipping %s\n' %
-          self.relpath)
+      print('________ found .git 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 41 matching lines @@
       # The repository url changed, need to switch.
       try:
         to_info = scm.SVN.CaptureInfo(url)
       except gclient_utils.Error:
         # 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:
-        options.stdout.write('\n_____ relocating %s to a new checkout\n' %
-            self.relpath)
+        print('\n_____ 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(self.checkout_path):
             if status[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.
-        options.stdout.write('\n_____ switching %s to a new checkout\n' %
-            self.relpath)
+        print('\n_____ switching %s to a new checkout' % self.relpath)
         gclient_utils.RemoveDirectory(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
 
     # 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:
-        options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
+        print('\n_____ %s%s' % (self.relpath, rev_str))
       return
 
     command = ['update', self.checkout_path]
     command = self._AddAdditionalUpdateFlags(command, options, revision)
     self._RunAndGetFileList(command, options, file_list, self._root_dir)
 
   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')):
@@ skipping 23 matching lines @@
 
   def revert(self, options, args, file_list):
     """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):
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      options.stdout.write('\n_____ %s is missing, synching instead\n' %
-          self.relpath)
+      print('\n_____ %s is missing, synching instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
-    # Do a flush of sys.stdout every 10 secs or so otherwise it may never be
-    # flushed fast enough for buildbot.
-    last_flushed_at = time.time()
-    sys.stdout.flush()
-
     for file_status in scm.SVN.CaptureStatus(self.checkout_path):
       file_path = os.path.join(self.checkout_path, file_status[1])
       if file_status[0][0] == 'X':
         # Ignore externals.
         logging.info('Ignoring external %s' % file_path)
         continue
 
       if logging.getLogger().isEnabledFor(logging.INFO):
         logging.info('%s%s' % (file[0], file[1]))
       else:
-        options.stdout.write(file_path + '\n')
-        # Flush at least 10 seconds between line writes.  We wait at least 10
-        # seconds to avoid overloading the reader that called us with output,
-        # which can slow busy readers down.
-        if (time.time() - last_flushed_at) > 10:
-          last_flushed_at = time.time()
-          sys.stdout.flush()
+        print(file_path)
 
       if file_status[0].isspace():
         logging.error('No idea what is the status of %s.\n'
                       'You just found a bug in gclient, please ping '
                       'maruel@chromium.org ASAP!' % file_path)
       # svn revert is really stupid. It fails on inconsistent line-endings,
       # on switched directories, etc. So take no chance and delete everything!
       try:
         if not os.path.exists(file_path):
           pass
@@ skipping 27 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.
-      options.stdout.write(
-          ('\n________ couldn\'t run \'%s\' in \'%s\':\nThe directory '
-           'does not exist.') % (' '.join(command), self.checkout_path))
+      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 FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url
 
   def _Run(self, args, options, **kwargs):
     """Runs a commands that goes to stdout."""
     kwargs.setdefault('cwd', self.checkout_path)
     gclient_utils.CheckCallAndFilterAndHeader(['svn'] + args,
-        always=options.verbose, stdout=options.stdout, **kwargs)
+        always=options.verbose, **kwargs)
 
   def _RunAndGetFileList(self, args, options, file_list, cwd=None):
     """Runs a commands that goes to stdout and grabs the file listed."""
     cwd = cwd or self.checkout_path
     scm.SVN.RunAndGetFileList(options.verbose, args, cwd=cwd,
-        file_list=file_list, stdout=options.stdout)
+        file_list=file_list)
 
   @staticmethod
   def _AddAdditionalUpdateFlags(command, options, revision):
     """Add additional flags to command depending on what options are set.
     command should be a list of strings that represents an svn command.
 
     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