Move call_with_timeout() guts into Proc.yield_any() generator.

run_test_cases.py

 #!/usr/bin/env python
 # 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.
 
 """Runs each test cases as a single shard, single process execution.
 
 Similar to sharding_supervisor.py but finer grained. It runs each test case
 individually instead of running per shard. Runs multiple instances in parallel.
 """
@@ skipping 181 matching lines @@
       # communicate() uses wait() internally.
       self.end = time.time()
     return ret
 
   def poll(self):
     ret = super(Popen, self).poll()
     if ret is not None and not self.end:
       self.end = time.time()
     return ret
 
+  def yield_any(self, timeout=None):
+    """Yields output until the process terminates or is killed by a timeout.
+
+    Yielded values are in the form (pipename, data).
+    """
+    remaining = 0

[csharp, 2013/03/21 19:14:16]

nit: remaining -> remaining_time

+    while self.poll() is None:
+      if timeout:
+        remaining = max(timeout - self.duration(), 0.001)
+      t, data = self.recv_any(timeout=remaining)
+      if data:
+        yield (t, data)
+      if timeout and self.duration() >= timeout:
+        break
+    if self.poll() is None and timeout and self.duration() >= timeout:
+      logging.debug('Kill %s %s', self.duration(), timeout)
+      self.kill()
+    self.wait()
+    # Try reading a last time.

[csharp, 2013/03/21 19:14:16]

nit: Try reading a last time -> Read all remaining output.

+    while True:
+      t, data = self.recv_any()
+      if not data:
+        break
+      yield (t, data)
+
   def recv_any(self, maxsize=None, timeout=None):
     """Reads from stderr and if empty, from stdout."""
     pipes = [
       x for x in ((self.stderr, 'stderr'), (self.stdout, 'stdout')) if x[0]
     ]
     if len(pipes) == 2 and self.stderr.fileno() == self.stdout.fileno():
       pipes.pop(0)
     if not pipes:
       return None, None
     conns, names = zip(*pipes)
@@ skipping 34 matching lines @@
 def call_with_timeout(cmd, timeout, **kwargs):
   """Runs an executable with an optional timeout."""
   proc = Popen(
       cmd,
       stdin=subprocess.PIPE,
       stdout=subprocess.PIPE,
       **kwargs)
   if timeout:
     out = ''
     err = ''
-    while proc.poll() is None:
-      remaining = max(timeout - proc.duration(), 0.001)
-      t, data = proc.recv_any(timeout=remaining)
-      if data:
-        if t == 'stdout':
-          out += data
-        else:
-          err += data
-      if proc.duration() >= timeout:
-        break
-    if proc.poll() is None and proc.duration() >= timeout:
-      logging.debug('Kill %s %s', proc.duration(), timeout)
-      proc.kill()
-    proc.wait()
-    # Try reading a last time.
-    while True:
-      t, data = proc.recv_any()
-      if not data:
-        break
+    for t, data in proc.yield_any(timeout):
       if t == 'stdout':
         out += data
       else:
         err += data
   else:
     # This code path is much faster.
     out, err = proc.communicate()
   return out, err, proc.returncode, proc.duration()
 
 
@@ skipping 1263 matching lines @@
         options.gtest_output,
         result_file,
         options.verbose)
   except Failure as e:
     print >> sys.stderr, e.args[0]
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))