[Android] Switch gtests to platform mode. (RELAND)

build/android/pylib/local/device/local_device_test_run.py

 # Copyright 2014 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.
 
 import logging
 
 from devil.android import device_errors
 from pylib import valgrind_tools
 from pylib.base import base_test_result
 from pylib.base import test_run
 from pylib.base import test_collection
 
 
+def handle_shard_failures(f):
+  """A decorator that handles device failures for per-device functions.
+
+  Args:
+    f: the function being decorated. The function must take at least one
+      argument, and that argument must be the device.
+  """
+  def wrapper(dev, *args, **kwargs):
+    try:
+      return f(dev, *args, **kwargs)
+    except device_errors.CommandFailedError:
+      logging.exception('Shard failed: %s(%s)', f.__name__, str(dev))
+    except device_errors.CommandTimeoutError:
+      logging.exception('Shard timed out: %s(%s)', f.__name__, str(dev))
+    except device_errors.DeviceUnreachableError:
+      logging.exception('Shard died: %s(%s)', f.__name__, str(dev))
+    return None
+
+  return wrapper
+
+
 class LocalDeviceTestRun(test_run.TestRun):
 
   def __init__(self, env, test_instance):
     super(LocalDeviceTestRun, self).__init__(env, test_instance)
     self._tools = {}
 
   #override
   def RunTests(self):
     tests = self._GetTests()
 
+    @handle_shard_failures
     def run_tests_on_device(dev, tests, results):
       for test in tests:
         try:
           result = self._RunTest(dev, test)
           if isinstance(result, base_test_result.BaseTestResult):
             results.AddResult(result)
           elif isinstance(result, list):
             results.AddResults(result)
           else:
             raise Exception(
@@ skipping 11 matching lines @@
     results = base_test_result.TestRunResults()
     all_fail_results = {}
     while tries < self._env.max_tries and tests:
       logging.info('STARTING TRY #%d/%d', tries + 1, self._env.max_tries)
       logging.info('Will run %d tests on %d devices: %s',
                    len(tests), len(self._env.devices),
                    ', '.join(str(d) for d in self._env.devices))
       for t in tests:
         logging.debug('  %s', t)
 
-      try:
-        try_results = base_test_result.TestRunResults()
-        if self._ShouldShard():
-          tc = test_collection.TestCollection(self._CreateShards(tests))
-          self._env.parallel_devices.pMap(
-              run_tests_on_device, tc, try_results).pGet(None)
-        else:
-          self._env.parallel_devices.pMap(
-              run_tests_on_device, tests, try_results).pGet(None)
-      except device_errors.CommandFailedError:
-        logging.exception('Shard terminated: command failed')
-      except device_errors.CommandTimeoutError:
-        logging.exception('Shard terminated: command timed out')
-      except device_errors.DeviceUnreachableError:
-        logging.exception('Shard terminated: device became unreachable')
+      try_results = base_test_result.TestRunResults()
+      if self._ShouldShard():
+        tc = test_collection.TestCollection(self._CreateShards(tests))
+        self._env.parallel_devices.pMap(
+            run_tests_on_device, tc, try_results).pGet(None)
+      else:
+        self._env.parallel_devices.pMap(
+            run_tests_on_device, tests, try_results).pGet(None)
 
       for result in try_results.GetAll():
         if result.GetType() in (base_test_result.ResultType.PASS,
                                 base_test_result.ResultType.SKIP):
           results.AddResult(result)
         else:
           all_fail_results[result.GetName()] = result
 
       results_names = set(r.GetName() for r in results.GetAll())
       tests = [t for t in tests if self._GetTestName(t) not in results_names]
@@ skipping 34 matching lines @@
     return test
 
   def _GetTests(self):
     raise NotImplementedError
 
   def _RunTest(self, device, test):
     raise NotImplementedError
 
   def _ShouldShard(self):
     raise NotImplementedError