Android gtest runner: Only query device for test list when necessary

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 os
 import posixpath
 
 from devil.android import device_errors
 from devil.android import device_temp_file
@@ skipping 34 matching lines @@
   for f in files:
     device_file = posixpath.join(device_dir, f)
     host_file = os.path.join(host_dir, *f.split(posixpath.sep))
     host_file_base, ext = os.path.splitext(host_file)
     for i in itertools.count():
       host_file = '%s_%d%s' % (host_file_base, i, ext)
       if not os.path.exists(host_file):
         break
     device.PullFile(device_file, host_file)
 
+
+def _ExtractTestsFromFilter(gtest_filter):
+  """Returns the list of tests specified by the given filter.
+
+  Returns:
+    None if the device should be queried for the test list instead.
+  """
+  # Empty means all tests, - means exclude filter.
+  if not gtest_filter or '-' in gtest_filter:
+    return None
+
+  patterns = gtest_filter.split(':')
+  # For a single pattern, allow it even if it has a wildcard so long as the
+  # wildcard comes at the end and there is at least one . to prove the scope is
+  # not too large.
+  # This heuristic is not necessarily faster, but normally is.
+  if len(patterns) == 1 and patterns[0].endswith('*'):
+    no_suffix = patterns[0].rstrip('*')
+    if '*' not in no_suffix and '.' in no_suffix:
+      return patterns
+
+  if '*' in gtest_filter:
+    return None
+  return patterns
+
+
 class _ApkDelegate(object):
   def __init__(self, test_instance):
     self._activity = test_instance.activity
     self._apk_helper = test_instance.apk_helper
     self._package = test_instance.package
     self._runner = test_instance.runner
     self._permissions = test_instance.permissions
 
     self._component = '%s/%s' % (self._package, self._runner)
     self._extras = test_instance.extras
@@ skipping 149 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):
+    # When the exact list of tests to run is given via command-line (e.g. when
+    # locally iterating on a specific test), skip querying the device (which
+    # takes ~3 seconds).
+    tests = _ExtractTestsFromFilter(self._test_instance.gtest_filter)
+    if tests:
+      return tests
+
+    # Even when there's only one device, it still makes sense to retrieve the
+    # test list so that tests can be split up and run in batches rather than all
+    # at once (since test output is not streamed).
     @local_device_test_run.handle_shard_failures_with(
         on_failure=self._env.BlacklistDevice)
     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
 
+    # Query all devices in case one fails.
     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
+    # TODO(agrieve): Make this fail rather than return an empty list when
+    #     all devices fail.
+    return list(sorted(set().union(*[set(tl) for tl in test_lists if tl])))
 
   #override
   def _RunTest(self, device, test):
     # Run the test.
     timeout = (self._test_instance.shard_timeout
                * 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.get(str(dev), []):
         s.TearDown()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)