Revert of [Android] Remove more uses of android_commands from build/android/pylib.

build/android/pylib/base/test_dispatcher.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.
 
 """Dispatches tests, either sharding or replicating them.
 
 Performs the following steps:
 * Create a test collection factory, using the given tests
   - If sharding: test collection factory returns the same shared test collection
     to all test runners
   - If replciating: test collection factory returns a unique test collection to
     each test runner, with the same set of tests in each.
 * Create a test runner for each device.
 * Run each test runner in its own thread, grabbing tests from the test
   collection until there are no tests left.
 """
 
 # TODO(jbudorick) Deprecate and remove this class after any relevant parts have
 # been ported to the new environment / test instance model.
 
 import logging
 import threading
 
+from pylib import android_commands
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.base import test_collection
 from pylib.device import device_errors
 from pylib.utils import reraiser_thread
 from pylib.utils import watchdog_timer
 
 
 DEFAULT_TIMEOUT = 7 * 60  # seven minutes
 
@@ skipping 60 matching lines @@
     new_test_run_results = base_test_result.TestRunResults()
     for test_result in test_run_results.GetAll():
       test_result.SetName('%s_%s' % (runner.device_serial[-4:],
                                      test_result.GetName()))
       new_test_run_results.AddResult(test_result)
     return new_test_run_results
 
   for test in collection:
     watcher.Reset()
     try:
-      if not runner.device.IsOnline():
+      if runner.device_serial not in android_commands.GetAttachedDevices():
         # Device is unresponsive, stop handling tests on this device.
         msg = 'Device %s is unresponsive.' % runner.device_serial
         logging.warning(msg)
         raise device_errors.DeviceUnreachableError(msg)
       result, retry = runner.RunTest(test.test)
       if tag_results_with_device:
         result = TagTestRunResults(result)
       test.tries += 1
       if retry and test.tries <= num_retries:
         # Retry non-passing results, only record passing results.
@@ skipping 27 matching lines @@
     device: The device serial number to set up.
     out_runners: List to add the successfully set up TestRunner object.
     threadsafe_counter: A _ThreadSafeCounter object used to get shard indices.
   """
   try:
     index = threadsafe_counter.GetAndIncrement()
     logging.warning('Creating shard %s for device %s.', index, device)
     runner = runner_factory(device, index)
     runner.SetUp()
     out_runners.append(runner)
-  except device_errors.DeviceUnreachableError as e:
+  except (device_errors.DeviceUnreachableError,
+          # TODO(jbudorick) Remove this once the underlying implementations
+          #                 for the above are switched or wrapped.
+          android_commands.errors.DeviceUnresponsiveError) as e:
     logging.warning('Failed to create shard for %s: [%s]', device, e)
 
 
 def _RunAllTests(runners, test_collection_factory, num_retries, timeout=None,
                  tag_results_with_device=False):
   """Run all tests using the given TestRunners.
 
   Args:
     runners: A list of TestRunner objects.
     test_collection_factory: A callable to generate a TestCollection object for
@@ skipping 21 matching lines @@
           [r, tc, results, watcher, num_retries, tag_results_with_device],
           name=r.device_serial[-4:])
       for r, tc in zip(runners, test_collections)]
 
   workers = reraiser_thread.ReraiserThreadGroup(threads)
   workers.StartAll()
 
   # Catch DeviceUnreachableErrors and set a warning exit code
   try:
     workers.JoinAll(watcher)
-  except device_errors.DeviceUnreachableError as e:
+  except (device_errors.DeviceUnreachableError,
+          # TODO(jbudorick) Remove this once the underlying implementations
+          #                 for the above are switched or wrapped.
+          android_commands.errors.DeviceUnresponsiveError) as e:
     logging.error(e)
 
   if not all((len(tc) == 0 for tc in test_collections)):
     logging.error('Only ran %d tests (all devices are likely offline).' %
                   len(results))
     for tc in test_collections:
       run_results.AddResults(base_test_result.BaseTestResult(
           t, base_test_result.ResultType.UNKNOWN) for t in tc.test_names())
 
   for r in results:
@@ skipping 17 matching lines @@
 
   Returns:
     A list of TestRunner objects.
   """
   logging.warning('Creating %s test runners.' % len(devices))
   runners = []
   counter = _ThreadSafeCounter()
   threads = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(_SetUp,
                                       [runner_factory, d, runners, counter],
-                                      name=str(d)[-4:])
+                                      name=d[-4:])
        for d in devices])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
   return runners
 
 
 def _TearDownRunners(runners, timeout=None):
   """Calls TearDown() for each test runner in parallel.
 
   Args:
@@ skipping 76 matching lines @@
 
   logging.info('Will run %d tests (%s): %s',
                len(tests_expanded), log_string, str(tests_expanded))
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
     return _RunAllTests(runners, test_collection_factory,
                         num_retries, test_timeout, tag_results_with_device)
   finally:
     try:
       _TearDownRunners(runners, setup_timeout)
-    except device_errors.DeviceUnreachableError as e:
+    except (device_errors.DeviceUnreachableError,
+            # TODO(jbudorick) Remove this once the underlying implementations
+            #                 for the above are switched or wrapped.
+            android_commands.errors.DeviceUnresponsiveError) as e:
       logging.warning('Device unresponsive during TearDown: [%s]', e)
     except Exception as e:
       logging.error('Unexpected exception caught during TearDown: %s' % str(e))