Cleanup the code in gclient_utils to standardize on CheckCall nomenclature.

gclient_utils.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 100 matching lines @@
 def GetNodeNamedAttributeText(node, node_name, attribute_name):
   child_nodes = node.getElementsByTagName(node_name)
   if not child_nodes:
     return None
   assert len(child_nodes) == 1
   return child_nodes[0].getAttribute(attribute_name)
 
 
 class Error(Exception):
   """gclient exception class."""
+  # TODO(maruel): Merge with CheckCallError.
   pass
 
 
 def SyntaxErrorToError(filename, e):
   """Raises a gclient_utils.Error exception with the human readable message"""
   try:
     # Try to construct a human readable error message
     if filename:
       error_message = 'There is a syntax error in %s\n' % filename
     else:
@@ skipping 113 matching lines @@
   try:
     os.rmdir(file_path)
   except OSError, e:
     if e.errno != errno.EACCES or sys.platform != 'win32':
       raise
     print 'Failed to remove %s: trying again' % file_path
     time.sleep(0.1)
     os.rmdir(file_path)
 
 
-def SubprocessCall(args, **kwargs):
-  """Wraps SubprocessCallAndFilter() with different default arguments.
+def CheckCallAndFilterAndHeader(args, always=False, **kwargs):
+  """Adds 'header' support to CheckCallAndFilter.
 
-  Calls subprocess and capture nothing."""
-  kwargs['print_messages'] = True
+  If |always| is True, a message indicating what is being done
+  is printed to stdout all the time even if not output is generated. Otherwise
+  the message header is printed only if the call generated any ouput.
+  """
+  stdout = kwargs.get('stdout', None) or sys.stdout
+  if always:
+    stdout.write('\n________ running \'%s\' in \'%s\'\n'
+        % (' '.join(args), kwargs.get('cwd', '.')))
+  else:
+    filter_fn = kwargs.get('filter_fn', None)
+    def filter_msg(line):
+      if line is None:
+        stdout.write('\n________ running \'%s\' in \'%s\'\n'
+            % (' '.join(args), kwargs.get('cwd', '.')))
+      elif filter_fn:
+        filter_fn(line)
+    kwargs['filter_fn'] = filter_msg
+    kwargs['call_filter_on_first_line'] = True
+  # Obviously.
   kwargs['print_stdout'] = True
-  return SubprocessCallAndFilter(args, **kwargs)
+  return CheckCallAndFilter(args, **kwargs)
 
 
-def SubprocessCallAndFilter(args, **kwargs):
-  """Runs a command and prints a header line if appropriate.
+def CheckCallAndFilter(args, stdout=None, filter_fn=None,
+                       print_stdout=None, call_filter_on_first_line=False,
+                       **kwargs):
+  """Runs a command and calls back a filter function if needed.
 
-  If |print_messages| is True, a message indicating what is being done
-  is printed to stdout. Otherwise the message is printed only if the call
-  generated any ouput. If both |print_messages| and |print_stdout| are False,
-  no output at all is generated.
+  Accepts all subprocess.Popen() parameters plus:
+    print_stdout: If True, the command's stdout is forwarded to stdout.
+    filter_fn: A function taking a single string argument called with each line
+               of the subprocess's output. Each line has the trailing newline
+               character trimmed.
+    stdout: Can be any bufferable output.
 
-  If |print_stdout| is True, the command's stdout is also forwarded to stdout.
-
-  If |filter_fn| function is specified, it is expected to take a single
-  string argument, and it will be called with each line of the
-  subprocess's output. Each line has had the trailing newline character
-  trimmed.
-
-  If the command fails, as indicated by a nonzero exit status, gclient will
-  exit with an exit status of fail_status. If fail_status is None (the
-  default), gclient will raise an Error exception.
-
-  Other subprocess.Popen parameters can be specified.
+  stderr is always redirected to stdout.
   """
-  stdout = kwargs.pop('stdout', sys.stdout) or sys.stdout
+  assert print_stdout or filter_fn
+  stdout = stdout or sys.stdout
+  filter_fn = filter_fn or (lambda x: None)
   assert not 'stderr' in kwargs
-  filter_fn = kwargs.pop('filter_fn', None)
-  print_messages = kwargs.pop('print_messages', False)
-  print_stdout = kwargs.pop('print_stdout', False)
-  fail_status = kwargs.pop('fail_status', None)
-
   logging.debug(args)
-  if print_messages:
-    stdout.write('\n________ running \'%s\' in \'%s\'\n'
-          % (' '.join(args), kwargs['cwd']))
-
   kid = Popen(args, bufsize=0,
               stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
               **kwargs)
 
-  # Do a flush of sys.stdout before we begin reading from the subprocess's
-  # stdout.
+  # Do a flush of stdout before we begin reading from the subprocess's stdout
   last_flushed_at = time.time()
   stdout.flush()
 
   # Also, we need to forward stdout to prevent weird re-ordering of output.
   # This has to be done on a per byte basis to make sure it is not buffered:
   # normally buffering is done for each line, but if svn requests input, no
   # end-of-line character is output after the prompt and it would not show up.
   in_byte = kid.stdout.read(1)
-  in_line = ''
-  while in_byte:
-    if in_byte != '\r':
-      if print_stdout:
-        if not print_messages:
-          stdout.write('\n________ running \'%s\' in \'%s\'\n'
-              % (' '.join(args), kwargs['cwd']))
-          print_messages = True
-        stdout.write(in_byte)
-      if in_byte != '\n':
-        in_line += in_byte
-    if in_byte == '\n':
-      if filter_fn:
-        filter_fn(in_line)
-      in_line = ''
-      # 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()
-        stdout.flush()
-    in_byte = kid.stdout.read(1)
-  # Flush the rest of buffered output. This is only an issue with files not
-  # ending with a \n.
-  if len(in_line) and filter_fn:
-    filter_fn(in_line)
+  if in_byte:
+    if call_filter_on_first_line:
+      filter_fn(None)
+    in_line = ''
+    while in_byte:
+      if in_byte != '\r':
+        if print_stdout:
+          stdout.write(in_byte)
+        if in_byte != '\n':
+          in_line += in_byte
+        else:
+          filter_fn(in_line)
+          in_line = ''
+          # 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()
+            stdout.flush()
+      in_byte = kid.stdout.read(1)
+    # Flush the rest of buffered output. This is only an issue with
+    # stdout/stderr not ending with a \n.
+    if len(in_line):
+      filter_fn(in_line)
   rv = kid.wait()
-
   if rv:
-    msg = 'failed to run command: %s' % ' '.join(args)
-    if fail_status != None:
-      sys.stderr.write(msg + '\n')
-      sys.exit(fail_status)
-    raise Error(msg)
+    raise Error('failed to run command: %s' % ' '.join(args))
+  return 0
 
 
 def FindGclientRoot(from_dir, filename='.gclient'):
   """Tries to find the gclient root."""
   path = os.path.realpath(from_dir)
   while not os.path.exists(os.path.join(path, filename)):
     split_path = os.path.split(path)
     if not split_path[1]:
       return None
     path = split_path[0]
@@ skipping 180 matching lines @@
         if exception:
           self.parent.exceptions.append(exception)
         if self.parent.progress:
           self.parent.progress.update(1)
         assert not self.item.name in self.parent.ran
         if not self.item.name in self.parent.ran:
           self.parent.ran.append(self.item.name)
       finally:
         self.parent.ready_cond.notifyAll()
         self.parent.ready_cond.release()