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

build/android/pylib/local/device/local_device_gtest_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 itertools
-import logging
 import os
 import posixpath
 
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import ports
 from pylib import constants
 from pylib.gtest import gtest_test_instance
 from pylib.local import local_test_server_spawner
 from pylib.local.device import local_device_environment
@@ skipping 84 matching lines @@
 
   def Install(self, device):
     # TODO(jbudorick): Look into merging this with normal data deps pushing if
     # executables become supported on nonlocal environments.
     host_device_tuples = [(self._exe_host_path, self._exe_device_path)]
     if self._deps_host_path:
       host_device_tuples.append((self._deps_host_path, self._deps_device_path))
     device.PushChangedFiles(host_device_tuples)
 
   def Run(self, test, device, flags=None, **kwargs):
-    cmd = [
-        self._test_run.GetTool(device).GetTestWrapper(),
-        self._exe_device_path,
-    ]
+    tool = self._test_run.GetTool(device).GetTestWrapper()
+    if tool:
+      cmd = [tool]
+    else:
+      cmd = []
+    cmd.append(self._exe_device_path)
+
     if test:
       cmd.append('--gtest_filter=%s' % ':'.join(test))
     if flags:
       cmd.append(flags)
     cwd = constants.TEST_EXECUTABLE_DIR
 
     env = {
       'LD_LIBRARY_PATH':
           '%s/%s_deps' % (constants.TEST_EXECUTABLE_DIR, self._exe_file_name),
     }
     try:
       gcov_strip_depth = os.environ['NATIVE_COVERAGE_DEPTH_STRIP']
       external = device.GetExternalStoragePath()
       env['GCOV_PREFIX'] = '%s/gcov' % external
       env['GCOV_PREFIX_STRIP'] = gcov_strip_depth
     except (device_errors.CommandFailedError, KeyError):
       pass
 
-    # TODO(jbudorick): Switch to just RunShellCommand once perezju@'s CL
-    # for long shell commands lands.
-    with device_temp_file.DeviceTempFile(device.adb) as script_file:
-      script_contents = ' '.join(cmd)
-      logging.info('script contents: %r', script_contents)
-      device.WriteFile(script_file.name, script_contents)
-      output = device.RunShellCommand(['sh', script_file.name], cwd=cwd,
-                                      env=env, **kwargs)
+    output = device.RunShellCommand(
+        cmd, cwd=cwd, env=env, check_return=True, large_output=True, **kwargs)
     return output
 
   def PullAppFiles(self, device, files, directory):
     pass
 
   def Clear(self, device):
     device.KillAll(self._exe_file_name, blocking=True, timeout=30, quiet=True)
 
 
 class LocalDeviceGtestRun(local_device_test_run.LocalDeviceTestRun):
@@ skipping 10 matching lines @@
 
     self._servers = {}
 
   #override
   def TestPackage(self):
     return self._test_instance.suite
 
   #override
   def SetUp(self):
 
+    @local_device_test_run.handle_shard_failures
     def individual_device_set_up(dev, host_device_tuples):
       # Install test APK.
       self._delegate.Install(dev)
 
       # Push data dependencies.
       external_storage = dev.GetExternalStoragePath()
       host_device_tuples = [
           (h, d if d is not None else external_storage)
           for h, d in host_device_tuples]
       dev.PushChangedFiles(host_device_tuples)
@@ skipping 19 matching lines @@
     device_count = len(self._env.devices)
     shards = []
     for i in xrange(0, device_count):
       unbounded_shard = tests[i::device_count]
       shards += [unbounded_shard[j:j+_MAX_SHARD_SIZE]
                  for j in xrange(0, len(unbounded_shard), _MAX_SHARD_SIZE)]
     return shards
 
   #override
   def _GetTests(self):
-    tests = self._delegate.Run(
-        None, self._env.devices[0], flags='--gtest_list_tests')
-    tests = gtest_test_instance.ParseGTestListTests(tests)
-    tests = self._test_instance.FilterTests(tests)
+    @local_device_test_run.handle_shard_failures
+    def list_tests(dev):
+      tests = self._delegate.Run(
+          None, dev, flags='--gtest_list_tests', timeout=10)
+      tests = gtest_test_instance.ParseGTestListTests(tests)
+      tests = self._test_instance.FilterTests(tests)
+      return tests
+
+    test_lists = self._env.parallel_devices.pMap(list_tests).pGet(None)
+    tests = list(sorted(set().union(*[set(tl) for tl in test_lists if tl])))
     return tests
 
   #override
   def _RunTest(self, device, test):
     # Run the test.
     timeout = 900 * self.GetTool(device).GetTimeoutScale()
     output = self._delegate.Run(
         test, device, timeout=timeout, retries=0)
     for s in self._servers[str(device)]:
       s.Reset()
     if self._test_instance.app_files:
       self._delegate.PullAppFiles(device, self._test_instance.app_files,
                                   self._test_instance.app_file_dir)
     self._delegate.Clear(device)
 
     # Parse the output.
     # TODO(jbudorick): Transition test scripts away from parsing stdout.
     results = self._test_instance.ParseGTestOutput(output)
     return results
 
   #override
   def TearDown(self):
+    @local_device_test_run.handle_shard_failures
     def individual_device_tear_down(dev):
       for s in self._servers[str(dev)]:
         s.TearDown()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)