Add java-side support for _incremental instrumentation tests

build/android/incremental_install/installer.py

 #!/usr/bin/env python
 #
 # Copyright 2015 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.
 
 """Install *_incremental.apk targets as well as their dependent files."""
 
 import argparse
 import glob
 import logging
 import os
 import posixpath
 import shutil
 import sys
+import zipfile
 
 sys.path.append(
     os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)))
 import devil_chromium
 from devil.android import apk_helper
 from devil.android import device_utils
 from devil.android import device_errors
 from devil.android.sdk import version_codes
 from devil.utils import reraiser_thread
 from pylib import constants
 from pylib.utils import run_tests_helper
 from pylib.utils import time_profile
 
 prev_sys_path = list(sys.path)
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir, 'gyp'))
 from util import build_utils
 sys.path = prev_sys_path
 
 
+def _DeviceCachePath(device):
+  file_name = 'device_cache_%s.json' % device.adb.GetDeviceSerial()
+  return os.path.join(constants.GetOutDirectory(), file_name)

[nyquist, 2016/02/10 07:08:32]

Does constants.GetOutDirectory magically change depending on where the args.gn
file lives? Or is this something we could pass in? It seems like people using GN
tend to use a bunch of different out-directories.

[agrieve, 2016/02/10 16:47:15]

It is somewhat comically named. There's a setter for it that is called based on
--output-directory, and it can also be changed with environment variables. Not
quite "constant" :P.

[jbudorick, 2016/02/10 16:53:14]

constants.GetOutDirectory() is one of my pet peeves that works well enough that
I haven't prioritized making it sane.

+
+
 def _TransformDexPaths(paths):
   """Given paths like ["/a/b/c", "/a/c/d"], returns ["b.c", "c.d"]."""
   if len(paths) == 1:
     return [os.path.basename(paths[0])]
 
   prefix_len = len(os.path.commonprefix(paths))
   return [p[prefix_len:].replace(os.sep, '.') for p in paths]
 
 
 def _Execute(concurrently, *funcs):
   """Calls all functions in |funcs| concurrently or in sequence."""
   timer = time_profile.TimeProfile()
   if concurrently:
     reraiser_thread.RunAsync(funcs)
   else:
     for f in funcs:
       f()
   timer.Stop(log=False)
   return timer
 
 
 def _GetDeviceIncrementalDir(package):
   """Returns the device path to put incremental files for the given package."""
   return '/data/local/tmp/incremental-app-%s' % package
 
 
-def Uninstall(device, package):
+def _HasClasses(jar_path):
+  """Returns whether the given jar contains classes.dex."""
+  with zipfile.ZipFile(jar_path) as jar:
+    return 'classes.dex' in jar.namelist()
+
+
+def Uninstall(device, package, enable_device_cache=False):
   """Uninstalls and removes all incremental files for the given package."""
   main_timer = time_profile.TimeProfile()
   device.Uninstall(package)
+  if enable_device_cache:
+    # Uninstall is rare, so just wipe the cache in this case.
+    cache_path = _DeviceCachePath(device)
+    if os.path.exists(cache_path):
+      os.unlink(cache_path)
   device.RunShellCommand(['rm', '-rf', _GetDeviceIncrementalDir(package)],
                          check_return=True)
   logging.info('Uninstall took %s seconds.', main_timer.GetDelta())
 
 
 def Install(device, apk, split_globs=None, native_libs=None, dex_files=None,
-            enable_device_cache=True, use_concurrency=True,
+            enable_device_cache=False, use_concurrency=True,
             show_proguard_warning=False):
   """Installs the given incremental apk and all required supporting files.
 
   Args:
     device: A DeviceUtils instance.
     apk: The path to the apk, or an ApkHelper instance.
     split_globs: Glob patterns for any required apk splits (optional).
     native_libs: List of app's native libraries (optional).
     dex_files: List of .dex.jar files that comprise the app's Dalvik code.
     enable_device_cache: Whether to enable on-device caching of checksums.
@@ skipping 39 matching lines @@
 
     if dex_files:
       push_dex_timer.Start()
       # Put all .dex files to be pushed into a temporary directory so that we
       # can use delete_device_stale=True.
       with build_utils.TempDir() as temp_dir:
         device_dex_dir = posixpath.join(device_incremental_dir, 'dex')
         # Ensure no two files have the same name.
         transformed_names = _TransformDexPaths(dex_files)
         for src_path, dest_name in zip(dex_files, transformed_names):
-          shutil.copy(src_path, os.path.join(temp_dir, dest_name))
+          # Binary targets with no extra classes create .dex.jar without a
+          # classes.dex (which Android chokes on).
+          if _HasClasses(src_path):
+            shutil.copy(src_path, os.path.join(temp_dir, dest_name))
         device.PushChangedFiles([(temp_dir, device_dex_dir)],
                                 delete_device_stale=True)
       push_dex_timer.Stop(log=False)
 
   def check_selinux():
     # Marshmallow has no filesystem access whatsoever. It might be possible to
     # get things working on Lollipop, but attempts so far have failed.
     # http://crbug.com/558818
     has_selinux = device.build_version_sdk >= version_codes.LOLLIPOP
     if has_selinux and apk.HasIsolatedProcesses():
       raise Exception('Cannot use incremental installs on Android L+ without '
                       'first disabling isoloated processes.\n'
                       'To do so, use GN arg:\n'
                       '    disable_incremental_isolated_processes=true')
 
-  cache_path = '%s/files-cache.json' % device_incremental_dir
+  cache_path = _DeviceCachePath(device)
   def restore_cache():
     if not enable_device_cache:
       logging.info('Ignoring device cache')
       return
-    # Delete the cached file so that any exceptions cause the next attempt
-    # to re-compute md5s.
-    cmd = 'P=%s;cat $P 2>/dev/null && rm $P' % cache_path
-    lines = device.RunShellCommand(cmd, check_return=False, large_output=True)
-    if lines:
-      device.LoadCacheData(lines[0])
+    if os.path.exists(cache_path):
+      logging.info('Using device cache: %s', cache_path)
+      with open(cache_path) as f:
+        device.LoadCacheData(f.read())
+      # Delete the cached file so that any exceptions cause it to be cleared.
+      os.unlink(cache_path)
     else:
-      logging.info('Device cache not found: %s', cache_path)
+      logging.info('No device cache present: %s', cache_path)
 
   def save_cache():
-    cache_data = device.DumpCacheData()
-    device.WriteFile(cache_path, cache_data)
+    with open(cache_path, 'w') as f:
+      f.write(device.DumpCacheData())
+      logging.info('Wrote device cache: %s', cache_path)
 
   # Create 2 lock files:
   # * install.lock tells the app to pause on start-up (until we release it).
   # * firstrun.lock is used by the app to pause all secondary processes until
   #   the primary process finishes loading the .dex / .so files.
   def create_lock_files():
     # Creates or zeros out lock files.
     cmd = ('D="%s";'
            'mkdir -p $D &&'
            'echo -n >$D/install.lock 2>$D/firstrun.lock')
@@ skipping 100 matching lines @@
       msg = ('More than one device available.\n'
              'Use --device=SERIAL to select a device.\n'
              'Available devices:\n')
       descriptions = all_devices.pMap(lambda d: d.build_description).pGet(None)
       for d, desc in zip(devices, descriptions):
         msg += '  %s (%s)\n' % (d, desc)
       raise Exception(msg)
 
   apk = apk_helper.ToHelper(args.apk_path)
   if args.uninstall:
-    Uninstall(device, apk.GetPackageName())
+    Uninstall(device, apk.GetPackageName(), enable_device_cache=args.cache)
   else:
     Install(device, apk, split_globs=args.splits, native_libs=args.native_libs,
             dex_files=args.dex_files, enable_device_cache=args.cache,
             use_concurrency=args.threading,
             show_proguard_warning=args.show_proguard_warning)
 
 
 if __name__ == '__main__':
   sys.exit(main())