Using lists is faster than cStringIO.

subprocess2.py

 # coding=utf8
 # Copyright (c) 2011 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.
 """Collection of subprocess wrapper functions.
 
 In theory you shouldn't need anything else in subprocess, or this module failed.
 """
 
 from __future__ import with_statement
@@ skipping 155 matching lines @@
     elif isinstance(args, (list, tuple)):
       tmp_str = ' '.join(args)
     else:
       raise CalledProcessError(None, args, kwargs.get('cwd'), None, None)
     if kwargs.get('cwd', None):
       tmp_str += ';  cwd=%s' % kwargs['cwd']
     logging.debug(tmp_str)
 
     self.stdout_cb = None
     self.stderr_cb = None
-    self.stdout_void = False
-    self.stderr_void = False
-    def fix(stream):
+    self.stdin_is_void = False
+    self.stdout_is_void = False
+    self.stderr_is_void = False
+
+    if kwargs.get('stdin') is VOID:
+      kwargs['stdin'] = open(os.devnull, 'r')
+      self.stdin_is_void = True
+
+    for stream in ('stdout', 'stderr'):
       if kwargs.get(stream) in (VOID, os.devnull):
-        # Replaces VOID with handle to /dev/null.
-        # Create a temporary file to workaround python's deadlock.
-        # http://docs.python.org/library/subprocess.html#subprocess.Popen.wait
-        # When the pipe fills up, it will deadlock this process. Using a real
-        # file works around that issue.
         kwargs[stream] = open(os.devnull, 'w')
-        setattr(self, stream + '_void', True)
+        setattr(self, stream + '_is_void', True)
       if callable(kwargs.get(stream)):
-        # Callable stdout/stderr should be used only with call() wrappers.
         setattr(self, stream + '_cb', kwargs[stream])
         kwargs[stream] = PIPE
 
-    fix('stdout')
-    fix('stderr')
-
     self.start = time.time()
     self.timeout = None
     self.shell = kwargs.get('shell', None)
     # Silence pylint on MacOSX
     self.returncode = None
 
     try:
       super(Popen, self).__init__(args, **kwargs)
     except OSError, e:
       if e.errno == errno.EAGAIN and sys.platform == 'cygwin':
@@ skipping 76 matching lines @@
     if self.timeout is not None:
       threads['timeout'] = threading.Thread(target=timeout_fn)
     if self.stdout_cb:
       threads['stdout'] = threading.Thread(
           target=_queue_pipe_read, args=(self.stdout, 'stdout'))
     if self.stderr_cb:
       threads['stderr'] = threading.Thread(
         target=_queue_pipe_read, args=(self.stderr, 'stderr'))
     if input:
       threads['stdin'] = threading.Thread(target=write_stdin)
+    elif self.stdin:
+      # Pipe but no input, make sure it's closed.
+      self.stdin.close()
     for t in threads.itervalues():
       t.start()
 
     timed_out = False
     try:
       # This thread needs to be optimized for speed.
       while threads:
         item = queue.get()
         if item[0] is 'stdout':
           self.stdout_cb(item[1])
@@ skipping 38 matching lines @@
 
     if self.timeout and self.shell:
       raise TypeError(
           'Using timeout and shell simultaneously will cause a process leak '
           'since the shell will be killed instead of the child process.')
 
     stdout = None
     stderr = None
     # Convert to a lambda to workaround python's deadlock.
     # http://docs.python.org/library/subprocess.html#subprocess.Popen.wait
-    # When the pipe fills up, it will deadlock this process. Using a thread
-    # works around that issue. No need for thread safe function since the call
-    # backs are guaranteed to be called from the main thread.
-    if self.stdout and not self.stdout_cb and not self.stdout_void:
-      stdout = cStringIO.StringIO()
-      self.stdout_cb = stdout.write
-    if self.stderr and not self.stderr_cb and not self.stderr_void:
-      stderr = cStringIO.StringIO()
-      self.stderr_cb = stderr.write
+    # When the pipe fills up, it would deadlock this process.
+    if self.stdout and not self.stdout_cb and not self.stdout_is_void:
+      stdout = []
+      self.stdout_cb = stdout.append
+    if self.stderr and not self.stderr_cb and not self.stderr_is_void:
+      stderr = []
+      self.stderr_cb = stderr.append
     self._tee_threads(input)
-    if stdout:
-      stdout = stdout.getvalue()
-    if stderr:
-      stderr = stderr.getvalue()
+    if stdout is not None:
+      stdout = ''.join(stdout)
+    stderr = None
+    if stderr is not None:
+      stderr = ''.join(stderr)
     return (stdout, stderr)
 
 
 def communicate(args, timeout=None, **kwargs):
   """Wraps subprocess.Popen().communicate() and add timeout support.
 
   Returns ((stdout, stderr), returncode).
 
   - The process will be killed after |timeout| seconds and returncode set to
     TIMED_OUT.
   - Automatically passes stdin content as input so do not specify stdin=PIPE.
   """
   stdin = kwargs.pop('stdin', None)
   if stdin is not None:
-    if stdin is VOID:
-      kwargs['stdin'] = open(os.devnull, 'r')
-      stdin = None
-    else:
-      assert isinstance(stdin, basestring)
+    if isinstance(stdin, basestring):
       # When stdin is passed as an argument, use it as the actual input data and
       # set the Popen() parameter accordingly.
       kwargs['stdin'] = PIPE
+    else:
+      kwargs['stdin'] = stdin
+      stdin = None
 
   proc = Popen(args, **kwargs)
-  if stdin not in (None, VOID):
+  if stdin:
     return proc.communicate(stdin, timeout), proc.returncode
   else:
     return proc.communicate(None, timeout), proc.returncode
 
 
 def call(args, **kwargs):
   """Emulates subprocess.call().
 
   Automatically convert stdout=PIPE or stderr=PIPE to VOID.
   In no case they can be returned since no code path raises
@@ skipping 45 matching lines @@
 
   - Throws if return code is not 0.
   - Works even prior to python 2.7.
   - Blocks stdin by default if not specified since no output will be visible.
   - As per doc, "The stdout argument is not allowed as it is used internally."
   """
   kwargs.setdefault('stdin', VOID)
   if 'stdout' in kwargs:
     raise ValueError('stdout argument not allowed, it will be overridden.')
   return check_call_out(args, stdout=PIPE, **kwargs)[0]