[Android] Dedup content_browsertests test setup from gtests.

build/android/pylib/gtest/setup.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.
 
 """Generates test runner factory and tests for GTests."""
 
 import fnmatch
 import glob
 import logging
 import os
 import shutil
 import sys
 
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import ports
 from pylib.base import base_test_result
 
 import gtest_config
+import test_package_apk
+import test_package_exe
 import test_runner
 
 sys.path.insert(0,
                 os.path.join(constants.DIR_SOURCE_ROOT, 'build', 'util', 'lib'))
 from common import unittest_util
 
 
 _ISOLATE_FILE_PATHS = {
     'base_unittests': 'base/base_unittests.isolate',
     'breakpad_unittests': 'breakpad/breakpad_unittests.isolate',
@@ skipping 110 matching lines @@
 
   # Move everything in PRODUCT_DIR to top level.
   deps_product_dir = os.path.join(constants.ISOLATE_DEPS_DIR, 'out', build_type)
   if os.path.isdir(deps_product_dir):
     for p in os.listdir(deps_product_dir):
       shutil.move(os.path.join(deps_product_dir, p), constants.ISOLATE_DEPS_DIR)
     os.rmdir(deps_product_dir)
     os.rmdir(os.path.join(constants.ISOLATE_DEPS_DIR, 'out'))
 
 
-def _GetSuitePath(use_exe_test_runner, suite_name, build_type):
-  """Get the absolute path to the test suite.
-
-  Args:
-    use_exe_test_runner: If True, use the executable-based test runner.
-    suite_name: The suite name specified on the command line.
-    build_type: 'Release' or 'Debug'.
-
-  Returns:
-    The absolute path of the given suite.
-    Ex. '/tmp/chrome/src/out/Debug/content_unittests_apk/'
-        'content_unittests-debug.apk'
-
-  Raises:
-    Exception: If test suite not found.
-  """
-  if use_exe_test_runner:
-    relpath = suite_name
-  else:
-    relpath = os.path.join(suite_name + '_apk', suite_name + '-debug.apk')
-  suite_path = os.path.join(cmd_helper.OutDirectory.get(), build_type, relpath)
-
-  if not os.path.exists(suite_path):
-    raise Exception('Test suite %s not found in %s.\n'
-                    'Supported test suites:\n %s\n'
-                    'Ensure it has been built.\n' %
-                    (suite_name, suite_path,
-                     [s.name for s in gtest_config.STABLE_TEST_SUITES]))
-
-  return suite_path
-
-
 def _GetDisabledTestsFilterFromFile(suite_name):
   """Returns a gtest filter based on the *_disabled file.
 
   Args:
     suite_name: Name of the test suite (e.g. base_unittests).
 
   Returns:
     A gtest filter which excludes disabled tests.
     Example: '*-StackTrace.*:StringPrintfTest.StringPrintfMisc'
   """
@@ skipping 20 matching lines @@
     runner_factory: Callable that takes device and shard_index and returns
         a TestRunner.
     devices: A list of device ids.
 
   Returns:
     All the tests in the test suite.
   """
   for device in devices:
     try:
       logging.info('Obtaining tests from %s', device)
-      runner = runner_factory(device, 0)
-      runner.test_package.Install()
-      return runner.test_package.GetAllTests()
+      return runner_factory(device, 0).GetAllTests()
     except (android_commands.errors.WaitForResponseTimedOutError,
             android_commands.errors.DeviceUnresponsiveError), e:
       logging.warning('Failed obtaining tests from %s with exception: %s',
                       device, e)
   raise Exception('No device available to get the list of tests.')
 
 
 def _FilterTestsUsingPrefixes(all_tests, pre=False, manual=False):
   """Removes tests with disabled prefixes.
 
   Args:
     all_tests: List of tests to filter.
-    pre: If True, include tests with _PRE prefix.
-    manual: If True, include tests with _MANUAL prefix.
+    pre: If True, include tests with PRE_ prefix.
+    manual: If True, include tests with MANUAL_ prefix.
 
   Returns:
     List of tests remaining.
   """
   filtered_tests = []
   filter_prefixes = ['DISABLED_', 'FLAKY_', 'FAILS_']
 
   if not pre:
     filter_prefixes.append('PRE_')
 
   if not manual:
     filter_prefixes.append('MANUAL_')
 
   for t in all_tests:
     test_case, test = t.split('.', 1)
     if not any([test_case.startswith(prefix) or test.startswith(prefix) for
                 prefix in filter_prefixes]):
       filtered_tests.append(t)
   return filtered_tests
 
 
-def GetTestsFiltered(suite_name, gtest_filter, runner_factory, devices):
+def _GetTestsFiltered(suite_name, gtest_filter, runner_factory, devices):
   """Get all tests in the suite and filter them.
 
   Obtains a list of tests from the test package on the device, and
   applies the following filters in order:
     1. Remove tests with disabled prefixes.
     2. Remove tests specified in the *_disabled files in the 'filter' dir
     3. Applies |gtest_filter|.
 
   Args:
     suite_name: Name of the test suite (e.g. base_unittests).
@@ skipping 10 matching lines @@
       tests, bool(gtest_filter), bool(gtest_filter))
   tests = unittest_util.FilterTestNames(
       tests, _GetDisabledTestsFilterFromFile(suite_name))
 
   if gtest_filter:
     tests = unittest_util.FilterTestNames(tests, gtest_filter)
 
   return tests
 
 
-def Setup(use_exe_test_runner, suite_name, test_arguments, timeout,
+def Setup(suite_name, test_arguments, timeout,
           cleanup_test_files, tool, build_type, push_deps,
           gtest_filter):
   """Create the test runner factory and tests.
 
   Args:
-    use_exe_test_runner: If True, use the executable-based test runner.
     suite_name: The suite name specified on the command line.
     test_arguments: Additional arguments to pass to the test binary.
     timeout: Timeout for each test.
     cleanup_test_files: Whether or not to cleanup test files on device.
     tool: Name of the Valgrind tool.
     build_type: 'Release' or 'Debug'.
     push_deps: If True, push all dependencies to the device.
     gtest_filter: Filter for tests.
 
   Returns:
     A tuple of (TestRunnerFactory, tests).
   """
 
   if not ports.ResetTestServerPortAllocation():
     raise Exception('Failed to reset test server port.')
 
-  suite_path = _GetSuitePath(use_exe_test_runner, suite_name, build_type)
+  test_package = test_package_apk.TestPackageApk(suite_name, build_type)
+  if not os.path.exists(test_package.suite_path):
+    test_package = test_package_exe.TestPackageExecutable(
+        suite_name, build_type)
+    if not os.path.exists(test_package.suite_path):
+      raise Exception(
+          'Did not find %s target. Ensure it has been built.' % suite_name)
+  logging.warning('Found target %s', test_package.suite_path)
 
-  # TODO(gkanwar): This breaks the abstraction of having test_dispatcher.py deal
-  # entirely with the devices. Can we do this another way?
-  attached_devices = android_commands.GetAttachedDevices()
+  _GenerateDepsDirUsingIsolate(suite_name, build_type)
 
-  deps_dir = _GenerateDepsDirUsingIsolate(suite_name, build_type)
   # Constructs a new TestRunner with the current options.
   def TestRunnerFactory(device, shard_index):
     return test_runner.TestRunner(
         device,
-        suite_path,
+        test_package,
         test_arguments,
         timeout,
         cleanup_test_files,
         tool,
         build_type,
-        push_deps,
-        constants.GTEST_TEST_PACKAGE_NAME,
-        constants.GTEST_TEST_ACTIVITY_NAME,
-        constants.GTEST_COMMAND_LINE_FILE)
+        push_deps)
 
-  # Get tests and split them up based on the number of devices.
-  tests = GetTestsFiltered(suite_name, gtest_filter,
-                           TestRunnerFactory, attached_devices)
-  num_devices = len(attached_devices)
-  tests = [':'.join(tests[i::num_devices]) for i in xrange(num_devices)]
-  tests = [t for t in tests if t]
+  attached_devices = android_commands.GetAttachedDevices()
+  tests = _GetTestsFiltered(suite_name, gtest_filter,
+                            TestRunnerFactory, attached_devices)
+  # Coalesce unit tests into a single test per device
+  if suite_name != 'content_browsertests':
+    num_devices = len(attached_devices)
+    tests = [':'.join(tests[i::num_devices]) for i in xrange(num_devices)]
+    tests = [t for t in tests if t]
 
   return (TestRunnerFactory, tests)