Seperate apk_info and jar_info.

build/android/pylib/utils/jar_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."""
+"""Gathers information about JARs such as test methods and annotations."""
 
 import collections
 import logging
 import os
 import pickle
 import re
 
-import cmd_helper
+# TODO(frankf): Move cmd_helper to utils.
+from pylib 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)
-  raise Exception('Failed to determine package name of %s' % apk_path)
 
+class JarInfo(object):
+  """Helper class for inspecting Jars."""
 
-class ApkInfo(object):
-  """Helper class for inspecting APKs."""
-
-  def __init__(self, apk_path, jar_path):
+  def __init__(self, jar_path):
     self._PROGUARD_PATH = os.path.join(os.environ['ANDROID_SDK_ROOT'],
                                        'tools/proguard/bin/proguard.sh')
     if not os.path.exists(self._PROGUARD_PATH):
       self._PROGUARD_PATH = os.path.join(os.environ['ANDROID_BUILD_TOP'],
                                          'external/proguard/bin/proguard.sh')
     self._PROGUARD_CLASS_RE = re.compile(r'\s*?- Program class:\s*([\S]+)$')
     self._PROGUARD_METHOD_RE = re.compile(r'\s*?- Method:\s*(\S*)[(].*$')
     self._PROGUARD_ANNOTATION_RE = re.compile(r'\s*?- Annotation \[L(\S*);\]:$')
     self._PROGUARD_ANNOTATION_CONST_RE = (
         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:
@@ skipping 67 matching lines @@
     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
-
-  def GetPackageName(self):
-    """Returns the package name of this APK."""
-    return GetPackageNameForApk(self._apk_path)
-
   def GetTestAnnotations(self, test):
     """Returns a list of all annotations for the given |test|. May be empty."""
     if not self._IsTestMethod(test):
       return []
     return self._GetAnnotationMap()[test]
 
   def _AnnotationsMatchFilters(self, annotation_filter_list, annotations):
     """Checks if annotations match any of the filters."""
     if not annotation_filter_list:
       return True
     for annotation_filter in annotation_filter_list:
       filters = annotation_filter.split('=')
       if len(filters) == 2:
         key = filters[0]
         value_list = filters[1].split(',')
         for value in value_list:
           if key + ':' + value in annotations:
             return True
       elif annotation_filter in annotations:
         return True
     return False
 
   def GetAnnotatedTests(self, annotation_filter_list):
     """Returns a list of all tests that match the given annotation filters."""
     return [test for test, annotations in self._GetAnnotationMap().iteritems()
             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."""
+    """Returns a list of all test methods in this jar as Class#testMethod."""
     return self._test_methods
 
   @staticmethod
   def IsPythonDrivenTest(test):
     return 'pythonDrivenTests' in test