Make repeated running of instrumentation tests faster.

build/android/pylib/apk_info.py

 # Copyright (c) 2012 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.
 
 """Gathers information about APKs."""
 
 import collections
+import logging
 import os
+import pickle
 import re
 
 import cmd_helper
 
+# If you change the cached output of proguard, increment this number
+PICKLE_FORMAT_VERSION = 1
 
 def GetPackageNameForApk(apk_path):
   """Returns the package name of the apk file."""
   aapt_output = cmd_helper.GetCmdOutput(
       ['aapt', 'dump', 'badging', apk_path]).split('\n')
   package_name_re = re.compile(r'package: .*name=\'(\S*)\'')
   for line in aapt_output:
     m = package_name_re.match(line)
     if m:
       return m.group(1)
@@ skipping 16 matching lines @@
         re.compile(r'\s*?- Constant element value.*$'))
     self._PROGUARD_ANNOTATION_VALUE_RE = re.compile(r'\s*?- \S+? \[(.*)\]$')
 
     if not os.path.exists(apk_path):
       raise Exception('%s not found, please build it' % apk_path)
     self._apk_path = apk_path
     if not os.path.exists(jar_path):
       raise Exception('%s not found, please build it' % jar_path)
     self._jar_path = jar_path
     self._annotation_map = collections.defaultdict(list)
+    self._pickled_proguard_name = self._jar_path + '-proguard.pickle'
     self._test_methods = []
     self._Initialize()
 
   def _Initialize(self):
+    if not self._GetCachedProguardData():
+      self._GetProguardData()
+
+  def _GetCachedProguardData(self):
+    if (os.path.exists(self._pickled_proguard_name) and
+        (os.path.getmtime(self._pickled_proguard_name) >
+         os.path.getmtime(self._jar_path))):
+      logging.info('Loading cached proguard output from %s',
+                   self._pickled_proguard_name)
+      try:
+        with open(self._pickled_proguard_name, 'r') as r:
+          d = pickle.loads(r.read())
+        if d['VERSION'] == PICKLE_FORMAT_VERSION:
+          self._annotation_map = d['ANNOTATION_MAP']
+          self._test_methods = d['TEST_METHODS']
+          return True
+      except:
+        logging.warning('PICKLE_FORMAT_VERSION has changed, ignoring cache')
+    return False
+
+  def _GetProguardData(self):
     proguard_output = cmd_helper.GetCmdOutput([self._PROGUARD_PATH,
                                                '-injars', self._jar_path,
                                                '-dontshrink',
                                                '-dontoptimize',
                                                '-dontobfuscate',
                                                '-dontpreverify',
                                                '-dump',
                                               ]).split('\n')
     clazz = None
     method = None
@@ skipping 28 matching lines @@
           if m:
             has_value = True
         else:
           m = self._PROGUARD_ANNOTATION_VALUE_RE.match(line)
           if m:
             value = m.group(1)
             self._annotation_map[qualified_method].append(
                 annotation + ':' + value)
             has_value = False
 
+    logging.info('Storing proguard output to %s', self._pickled_proguard_name)
+    d = {'VERSION': PICKLE_FORMAT_VERSION,
+         'ANNOTATION_MAP': self._annotation_map,
+         'TEST_METHODS': self._test_methods}
+    with open(self._pickled_proguard_name, 'w') as f:
+      f.write(pickle.dumps(d))
+
   def _GetAnnotationMap(self):
     return self._annotation_map
 
   def _IsTestMethod(self, test):
     class_name, method = test.split('#')
     return class_name.endswith('Test') and method.startswith('test')
 
   def GetApkPath(self):
     return self._apk_path
 
@@ skipping 29 matching lines @@
             if self._IsTestMethod(test) and self._AnnotationsMatchFilters(
                 annotation_filter_list, annotations)]
 
   def GetTestMethods(self):
     """Returns a list of all test methods in this apk as Class#testMethod."""
     return self._test_methods
 
   @staticmethod
   def IsPythonDrivenTest(test):
     return 'pythonDrivenTests' in test