GN Incremental Install: Reinstall apk regardless of cached values

build/android/devil/android/device_utils.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.
 
 """Provides a variety of device interactions based on adb.
 
 Eventually, this will be based on adb_wrapper.
 """
 # pylint: disable=unused-argument
 
@@ skipping 361 matching lines @@
       package: Name of the package.
 
     Returns:
       List of paths to the apks on the device for the given package.
     """
     return self._GetApplicationPathsInternal(package)
 
   def _GetApplicationPathsInternal(self, package, skip_cache=False):
     cached_result = self._cache['package_apk_paths'].get(package)
     if cached_result is not None and not skip_cache:
-      return list(cached_result)
+      if package in self._cache['package_apk_paths_to_verify']:
+        self._cache['package_apk_paths_to_verify'].remove(package)
+        # Don't verify an app that is not thought to be installed. We are
+        # concerned only with apps we think are installed having been
+        # uninstalled manually.
+        if cached_result and not self.PathExists(cached_result):
+          cached_result = None
+          self._cache['package_apk_checksums'].pop(package, 0)
+      if cached_result is not None:
+        return list(cached_result)
     # 'pm path' is liable to incorrectly exit with a nonzero number starting
     # in Lollipop.
     # TODO(jbudorick): Check if this is fixed as new Android versions are
     # released to put an upper bound on this.
     should_check_return = (self.build_version_sdk < version_codes.LOLLIPOP)
     output = self.RunShellCommand(
         ['pm', 'path', package], check_return=should_check_return)
     apks = []
     for line in output:
       if not line.startswith('package:'):
@@ skipping 1549 matching lines @@
       self._client_caches[client_name] = {}
     return self._client_caches[client_name]
 
   def _ClearCache(self):
     """Clears all caches."""
     for client in self._client_caches:
       self._client_caches[client].clear()
     self._cache = {
         # Map of packageId -> list of on-device .apk paths
         'package_apk_paths': {},
+        # Set of packageId that were loaded from LoadCacheData and not yet
+        # verified.
+        'package_apk_paths_to_verify': set(),
         # Map of packageId -> set of on-device .apk checksums
         'package_apk_checksums': {},
         # Map of property_name -> value
         'getprop': {},
         # Map of device_path -> [ignore_other_files, map of path->checksum]
         'device_path_checksums': {},
     }
 
   def LoadCacheData(self, data):
     """Initializes the cache from data created using DumpCacheData."""
     obj = json.loads(data)
     self._cache['package_apk_paths'] = obj.get('package_apk_paths', {})
+    # When using a cache across script invokations, verify that apps have
+    # not been uninstalled.
+    self._cache['package_apk_paths_to_verify'] = set(
+        self._cache['package_apk_paths'].iterkeys())
+
     package_apk_checksums = obj.get('package_apk_checksums', {})
     for k, v in package_apk_checksums.iteritems():
       package_apk_checksums[k] = set(v)
     self._cache['package_apk_checksums'] = package_apk_checksums
     device_path_checksums = obj.get('device_path_checksums', {})
     self._cache['device_path_checksums'] = device_path_checksums
 
   def DumpCacheData(self):
     """Dumps the current cache state to a string."""
     obj = {}
@@ skipping 65 matching lines @@
     if ('android.permission.WRITE_EXTERNAL_STORAGE' in permissions
         and 'android.permission.READ_EXTERNAL_STORAGE' not in permissions):
       permissions.append('android.permission.READ_EXTERNAL_STORAGE')
     cmd = ';'.join('pm grant %s %s' %(package, p) for p in permissions)
     if cmd:
       output = self.RunShellCommand(cmd)
       if output:
         logging.warning('Possible problem when granting permissions. Blacklist '
                         'may need to be updated.')
         logging.warning(output)