[Android] Extract MD5sum logic.

build/android/pylib/instrumentation/test_jar.py

 # Copyright (c) 2013 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.
 
 """Helper class for instrumenation test jar."""
 # pylint: disable=W0702
 
 import logging
 import os
 import pickle
 import re
 import sys
 
 from pylib import cmd_helper
 from pylib import constants
 from pylib.device import device_utils
+from pylib.utils import md5sum
 from pylib.utils import proguard
 
 sys.path.insert(0,
                 os.path.join(constants.DIR_SOURCE_ROOT,
                              'build', 'util', 'lib', 'common'))
 
 import unittest_util # pylint: disable=F0401
 
 # If you change the cached output of proguard, increment this number
 PICKLE_FORMAT_VERSION = 4
@@ skipping 21 matching lines @@
                                        'tools/proguard/lib/proguard.jar')
     if not os.path.exists(self._PROGUARD_PATH):
       self._PROGUARD_PATH = os.path.join(os.environ['ANDROID_BUILD_TOP'],
                                          'external/proguard/lib/proguard.jar')
     self._jar_path = jar_path
     self._pickled_proguard_name = self._jar_path + '-proguard.pickle'
     self._test_methods = {}
     if not self._GetCachedProguardData():
       self._GetProguardData()
 
-  @staticmethod
-  def _CalculateMd5(path):
-    # TODO(jbudorick): Move MD5sum calculations out of here and
-    # AndroidCommands to their own module.
-    out = cmd_helper.GetCmdOutput(
-        [os.path.join(constants.GetOutDirectory(),
-                      'md5sum_bin_host'),
-        path])
-    return out
-
   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())
-        jar_md5 = self._CalculateMd5(self._jar_path)
+        jar_md5 = md5sum.CalculateHostMd5Sums(self._jar_path)[0].hash
         if (d['JAR_MD5SUM'] == jar_md5 and
             d['VERSION'] == PICKLE_FORMAT_VERSION):
           self._test_methods = d['TEST_METHODS']
           return True
       except:
         logging.warning('PICKLE_FORMAT_VERSION has changed, ignoring cache')
     return False
 
   def _GetProguardData(self):
     logging.info('Retrieving test methods via proguard.')
@@ skipping 19 matching lines @@
       for m in test_methods:
         qualified_method = '%s#%s' % (c['class'], m['method'])
         annotations = dict(class_annotations)
         annotations.update(m['annotations'])
         self._test_methods[qualified_method] = m
         self._test_methods[qualified_method]['annotations'] = annotations
 
     logging.info('Storing proguard output to %s', self._pickled_proguard_name)
     d = {'VERSION': PICKLE_FORMAT_VERSION,
          'TEST_METHODS': self._test_methods,
-         'JAR_MD5SUM': self._CalculateMd5(self._jar_path)}
+         'JAR_MD5SUM': md5sum.CalculateHostMd5Sums(self._jar_path)[0].hash}
     with open(self._pickled_proguard_name, 'w') as f:
       f.write(pickle.dumps(d))
 
   @staticmethod
   def _IsTestMethod(test):
     class_name, method = test.split('#')
     return class_name.endswith('Test') and method.startswith('test')
 
   def GetTestAnnotations(self, test):
     """Returns a list of all annotations for the given |test|. May be empty."""
@@ skipping 101 matching lines @@
         device_utils.DeviceUtils.parallel().GetProp(
             'ro.build.version.sdk').pGet(None)]
     tests = [t for t in tests
              if self._IsTestValidForSdkRange(t, min(sdk_versions))]
 
     return tests
 
   @staticmethod
   def IsHostDrivenTest(test):
     return 'pythonDrivenTests' in test