Add option to push files to device using isolate for instrumentation tests.

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."""
 # pylint: disable=W0212
 
 import logging
 import os
 import sys
 
 from pylib import constants
-from pylib import valgrind_tools
 
+from pylib.base import base_setup
 from pylib.base import base_test_result
 from pylib.base import test_dispatcher
 from pylib.device import device_utils
 from pylib.gtest import test_package_apk
 from pylib.gtest import test_package_exe
 from pylib.gtest import test_runner
-from pylib.utils import isolator
 
 sys.path.insert(0,
                 os.path.join(constants.DIR_SOURCE_ROOT, 'build', 'util', 'lib',
                              'common'))
 import unittest_util # pylint: disable=F0401
 
 
-_ISOLATE_FILE_PATHS = {
+ISOLATE_FILE_PATHS = {
     'base_unittests': 'base/base_unittests.isolate',
     'blink_heap_unittests':
       'third_party/WebKit/Source/platform/heap/BlinkHeapUnitTests.isolate',
     'breakpad_unittests': 'breakpad/breakpad_unittests.isolate',
     'cc_perftests': 'cc/cc_perftests.isolate',
     'components_unittests': 'components/components_unittests.isolate',
     'content_browsertests': 'content/content_browsertests.isolate',
     'content_unittests': 'content/content_unittests.isolate',
     'media_perftests': 'media/media_perftests.isolate',
     'media_unittests': 'media/media_unittests.isolate',
     'net_unittests': 'net/net_unittests.isolate',
     'sql_unittests': 'sql/sql_unittests.isolate',
     'ui_base_unittests': 'ui/base/ui_base_tests.isolate',
     'ui_unittests': 'ui/base/ui_base_tests.isolate',
     'unit_tests': 'chrome/unit_tests.isolate',
     'webkit_unit_tests':
       'third_party/WebKit/Source/web/WebKitUnitTests.isolate',
 }
 
 # Used for filtering large data deps at a finer grain than what's allowed in
 # isolate files since pushing deps to devices is expensive.
 # Wildcards are allowed.
-_DEPS_EXCLUSION_LIST = [
+DEPS_EXCLUSION_LIST = [
     'chrome/test/data/extensions/api_test',
     'chrome/test/data/extensions/secure_shell',
     'chrome/test/data/firefox*',
     'chrome/test/data/gpu',
     'chrome/test/data/image_decoding',
     'chrome/test/data/import',
     'chrome/test/data/page_cycler',
     'chrome/test/data/perf',
     'chrome/test/data/pyauto_private',
     'chrome/test/data/safari_import',
     'chrome/test/data/scroll',
     'chrome/test/data/third_party',
     'third_party/hunspell_dictionaries/*.dic',
     # crbug.com/258690
     'webkit/data/bmp_decoder',
     'webkit/data/ico_decoder',
 ]
 
 
-def _GenerateDepsDirUsingIsolate(suite_name, isolate_file_path=None):
-  """Generate the dependency dir for the test suite using isolate.
-
-  Args:
-    suite_name: Name of the test suite (e.g. base_unittests).
-    isolate_file_path: .isolate file path to use. If there is a default .isolate
-                       file path for the suite_name, this will override it.
-  """
-  if isolate_file_path:
-    if os.path.isabs(isolate_file_path):
-      isolate_abs_path = isolate_file_path
-    else:
-      isolate_abs_path = os.path.join(constants.DIR_SOURCE_ROOT,
-                                      isolate_file_path)
-  else:
-    isolate_rel_path = _ISOLATE_FILE_PATHS.get(suite_name)
-    if not isolate_rel_path:
-      logging.info('Did not find an isolate file for the test suite.')
-      return
-    isolate_abs_path = os.path.join(constants.DIR_SOURCE_ROOT, isolate_rel_path)
-
-  isolated_abs_path = os.path.join(
-      constants.GetOutDirectory(), '%s.isolated' % suite_name)
-  assert os.path.exists(isolate_abs_path), 'Cannot find %s' % isolate_abs_path
-
-  i = isolator.Isolator(constants.ISOLATE_DEPS_DIR)
-  i.Clear()
-  i.Remap(isolate_abs_path, isolated_abs_path)
-  # We're relying on the fact that timestamps are preserved
-  # by the remap command (hardlinked). Otherwise, all the data
-  # will be pushed to the device once we move to using time diff
-  # instead of md5sum. Perform a sanity check here.
-  i.VerifyHardlinks()
-  i.PurgeExcluded(_DEPS_EXCLUSION_LIST)
-  i.MoveOutputDeps()
-
-
 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 88 matching lines @@
     List of tests remaining.
   """
   tests = _FilterTestsUsingPrefixes(
       tests, has_gtest_filter, has_gtest_filter)
   tests = unittest_util.FilterTestNames(
       tests, _GetDisabledTestsFilterFromFile(suite_name))
 
   return tests
 
 
-def PushDataDeps(device, test_options, test_package):
-  valgrind_tools.PushFilesForTool(test_options.tool, device)
-  if os.path.exists(constants.ISOLATE_DEPS_DIR):
-    device_dir = (
-        constants.TEST_EXECUTABLE_DIR
-        if test_package.suite_name == 'breakpad_unittests'
-        else device.GetExternalStoragePath())
-    device.PushChangedFiles([
-        (os.path.join(constants.ISOLATE_DEPS_DIR, p),
-         '%s/%s' % (device_dir, p))
-        for p in os.listdir(constants.ISOLATE_DEPS_DIR)])
-
-
 def Setup(test_options, devices):
   """Create the test runner factory and tests.
 
   Args:
     test_options: A GTestOptions object.
     devices: A list of attached devices.
 
   Returns:
     A tuple of (TestRunnerFactory, tests).
   """
   test_package = test_package_apk.TestPackageApk(test_options.suite_name)
   if not os.path.exists(test_package.suite_path):
     exe_test_package = test_package_exe.TestPackageExecutable(
         test_options.suite_name)
     if not os.path.exists(exe_test_package.suite_path):
       raise Exception(
           'Did not find %s target. Ensure it has been built.\n'
           '(not found at %s or %s)'
           % (test_options.suite_name,
              test_package.suite_path,
              exe_test_package.suite_path))
     test_package = exe_test_package
   logging.warning('Found target %s', test_package.suite_path)
 
-  _GenerateDepsDirUsingIsolate(test_options.suite_name,
-                               test_options.isolate_file_path)
-
+  base_setup.GenerateDepsDirUsingIsolate(test_options.suite_name,
+                                         test_options.isolate_file_path,
+                                         ISOLATE_FILE_PATHS,
+                                         DEPS_EXCLUSION_LIST)
+  def DeviceDir(device):
+    return (constants.TEST_EXECUTABLE_DIR
+        if test_package.suite_name == 'breakpad_unittests'
+        else device.GetExternalStoragePath())
   device_utils.DeviceUtils.parallel(devices).pMap(
-      PushDataDeps, test_options, test_package)
+      (lambda d, opts: base_setup.PushDataDeps(d, DeviceDir(d), opts)),

[jbudorick, 2014/11/03 15:52:32]

Instead of defining DeviceDir as a separate function, define this entire lambda
and pMap that.

[mikecase (-- gone --), 2014/11/06 00:12:21]

Done.

+      test_options)
 
   tests = _GetTests(test_options, test_package, devices)
 
   # Constructs a new TestRunner with the current options.
   def TestRunnerFactory(device, _shard_index):
     return test_runner.TestRunner(
         test_options,
         device,
         test_package)
 
   if test_options.run_disabled:
     test_options = test_options._replace(
         test_arguments=('%s --gtest_also_run_disabled_tests' %
                         test_options.test_arguments))
   else:
     tests = _FilterDisabledTests(tests, test_options.suite_name,
                                  bool(test_options.gtest_filter))
   if test_options.gtest_filter:
     tests = unittest_util.FilterTestNames(tests, test_options.gtest_filter)
 
   # Coalesce unit tests into a single test per device
   if test_options.suite_name != 'content_browsertests':
     num_devices = len(devices)
     tests = [':'.join(tests[i::num_devices]) for i in xrange(num_devices)]
     tests = [t for t in tests if t]
 
   return (TestRunnerFactory, tests)