Android Add _incremental targets for instrumentation tests

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 collections
-import imp
 import itertools
 import os
 import posixpath
 
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import ports
 from devil.utils import reraiser_thread
-from incremental_install import installer
 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
 from pylib.local.device import local_device_test_run
 
 _COMMAND_LINE_FLAGS_SUPPORTED = True
 
 _MAX_INLINE_FLAGS_LENGTH = 50  # Arbitrarily chosen.
 _EXTRA_COMMAND_LINE_FILE = (
@@ skipping 66 matching lines @@
 
   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._test_apk_incremental_install_script = (
+        test_instance.test_apk_incremental_install_script)
     self._package = test_instance.package
     self._runner = test_instance.runner
     self._permissions = test_instance.permissions
     self._suite = test_instance.suite
     self._component = '%s/%s' % (self._package, self._runner)
     self._extras = test_instance.extras
 
-  def Install(self, device, incremental=False):
-    if not incremental:
+  def Install(self, device):
+    if self._test_apk_incremental_install_script:
+      local_device_test_run.IncrementalInstall(device, self._apk_helper,
+          self._test_apk_incremental_install_script)
+    else:
       device.Install(self._apk_helper, reinstall=True,
                      permissions=self._permissions)
-      return
-
-    installer_script = os.path.join(constants.GetOutDirectory(), 'bin',
-                                    'install_%s_apk_incremental' % self._suite)
-    try:
-      install_wrapper = imp.load_source('install_wrapper', installer_script)
-    except IOError:
-      raise Exception(('Incremental install script not found: %s\n'
-                       'Make sure to first build "%s_incremental"') %
-                      (installer_script, self._suite))
-    params = install_wrapper.GetInstallParameters()
-
-    installer.Install(device, self._apk_helper, split_globs=params['splits'],
-                      native_libs=params['native_libs'],
-                      dex_files=params['dex_files'])
 
   def Run(self, test, device, flags=None, **kwargs):
     extras = dict(self._extras)
 
     if ('timeout' in kwargs
         and gtest_test_instance.EXTRA_SHARD_NANO_TIMEOUT not in extras):
       # Make sure the instrumentation doesn't kill the test before the
       # scripts do. The provided timeout value is in seconds, but the
       # instrumentation deals with nanoseconds because that's how Android
       # handles time.
@@ skipping 40 matching lines @@
     self._exe_device_path = '%s/%s' % (
         constants.TEST_EXECUTABLE_DIR, self._exe_file_name)
     deps_host_path = self._exe_host_path + '_deps'
     if os.path.exists(deps_host_path):
       self._deps_host_path = deps_host_path
       self._deps_device_path = self._exe_device_path + '_deps'
     else:
       self._deps_host_path = None
     self._test_run = tr
 
-  def Install(self, device, incremental=False):
-    assert not incremental
+  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):
     tool = self._test_run.GetTool(device).GetTestWrapper()
     if tool:
@@ skipping 49 matching lines @@
   def TestPackage(self):
     return self._test_instance.suite
 
   #override
   def SetUp(self):
     @local_device_test_run.handle_shard_failures_with(
         on_failure=self._env.BlacklistDevice)
     def individual_device_set_up(dev):
       def install_apk():
         # Install test APK.
-        self._delegate.Install(dev, incremental=self._env.incremental_install)
+        self._delegate.Install(dev)
 
       def push_test_data():
         # Push data dependencies.
         external_storage = dev.GetExternalStoragePath()
         data_deps = self._test_instance.GetDataDependencies()
         host_device_tuples = [
             (h, d if d is not None else external_storage)
             for h, d in data_deps]
         dev.PushChangedFiles(host_device_tuples)
 
@@ skipping 87 matching lines @@
   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()
 
       tool = self.GetTool(dev)
       tool.CleanUpEnvironment()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)