Android Incremental Install Always use the same device cache

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
@@ skipping 14 matching lines @@
 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)
+
+
 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 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,

[jbudorick, 2016/02/08 16:32:46]

What's the point of flipping this default?

[agrieve, 2016/02/08 16:35:44]

test_runner.py uses this function to install incremental apks, and was not
setting it to false explicitly. Since test_runner.py had enabled its own device
cache, this was causing a second device cached to be loaded. 

We only ever want the outer-most script to read/write the cache I think, so I
made this False by default.

             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 55 matching lines @@
     # 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())