Make TimeoutRetryThread's stoppable

build/android/pylib/utils/reraiser_thread.py

 # Copyright 2013 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.
 
 """Thread and ThreadGroup that reraise exceptions on the main thread."""
 # pylint: disable=W0212
 
 import logging
 import sys
 import threading
@@ skipping 86 matching lines @@
     Args:
       thread: a ReraiserThread object.
     """
     self._threads.append(thread)
 
   def StartAll(self):
     """Start all threads."""
     for thread in self._threads:
       thread.start()
 
-  def _JoinAll(self, watcher=watchdog_timer.WatchdogTimer(None)):
+  def _JoinAll(self, watcher):
     """Join all threads without stack dumps.
 
     Reraises exceptions raised by the child threads and supports breaking
     immediately on exceptions raised on the main thread.
 
     Args:
       watcher: Watchdog object providing timeout, by default waits forever.
     """
     alive_threads = self._threads[:]
     while alive_threads:
       for thread in alive_threads[:]:
         if watcher.IsTimedOut():
           raise TimeoutError('Timed out waiting for %d of %d threads.' %

[jbudorick, 2014/10/28 17:28:46]

One other thing to consider (which you may already have considered): can we do
something here with the threads still in alive_threads?

                              (len(alive_threads), len(self._threads)))
         # Allow the main thread to periodically check for interrupts.
         thread.join(0.1)
         if not thread.isAlive():
           alive_threads.remove(thread)
     # All threads are allowed to complete before reraising exceptions.
     for thread in self._threads:
       thread.ReraiseIfException()
 
-  def JoinAll(self, watcher=watchdog_timer.WatchdogTimer(None)):
+  def JoinAll(self, watcher=None):
     """Join all threads.
 
     Reraises exceptions raised by the child threads and supports breaking
     immediately on exceptions raised on the main thread. Unfinished threads'
     stacks will be logged on watchdog timeout.
 
     Args:
       watcher: Watchdog object providing timeout, by default waits forever.
     """
+    if watcher is None:
+      watcher = watchdog_timer.WatchdogTimer(None)
     try:
       self._JoinAll(watcher)
     except TimeoutError:
       for thread in (t for t in self._threads if t.isAlive()):
         LogThreadStack(thread)
       raise
 
-  def GetAllReturnValues(self, watcher=watchdog_timer.WatchdogTimer(None)):
+  def GetAllReturnValues(self, watcher=None):
     """Get all return values, joining all threads if necessary.
 
     Args:
       watcher: same as in |JoinAll|. Only used if threads are alive.
     """
     if any([t.isAlive() for t in self._threads]):
       self.JoinAll(watcher)
     return [t.GetReturnValue() for t in self._threads]