Android: upstream latest changes for build/android.

build/android/pylib/android_commands.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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
@@ skipping 23 matching lines @@
 
 # Pattern to search for the next whole line of pexpect output and capture it
 # into a match group. We can't use ^ and $ for line start end with pexpect,
 # see http://www.noah.org/python/pexpect/#doc for explanation why.
 PEXPECT_LINE_RE = re.compile('\n([^\r]*)\r')
 
 # Set the adb shell prompt to be a unique marker that will [hopefully] not
 # appear at the start of any line of a command's output.
 SHELL_PROMPT = '~+~PQ\x17RS~+~'
 
-# This only works for single core devices.
-SCALING_GOVERNOR = '/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor'
-DROP_CACHES = '/proc/sys/vm/drop_caches'
-
 # Java properties file
 LOCAL_PROPERTIES_PATH = '/data/local.prop'
 
 # Property in /data/local.prop that controls Java assertions.
 JAVA_ASSERT_PROPERTY = 'dalvik.vm.enableassertions'
 
 BOOT_COMPLETE_RE = re.compile(
     'android.intent.action.MEDIA_MOUNTED path: /\w+/sdcard\d?'
     '|PowerManagerService(\(\s+\d+\))?: bootCompleted')
 
@@ skipping 141 matching lines @@
   Args:
     device: If given, adb commands are only send to the device of this ID.
         Otherwise commands are sent to all attached devices.
   """
 
   def __init__(self, device=None):
     self._adb = adb_interface.AdbInterface()
     if device:
       self._adb.SetTargetSerial(device)
     self._logcat = None
-    self._original_governor = None
     self._pushed_files = []
     self._device_utc_offset = self.RunShellCommand('date +%z')[0]
     self._md5sum_path = ''
+    self._external_storage = ''
 
   def Adb(self):
     """Returns our AdbInterface to avoid us wrapping all its methods."""
     return self._adb
 
   def IsRootEnabled(self):
     """Checks if root is enabled on the device."""
     root_test_output = self.RunShellCommand('ls /root') or ['']
     return not 'Permission denied' in root_test_output[0]
 
   def GetDeviceYear(self):
     """Returns the year information of the date on device."""
     return self.RunShellCommand('date +%Y')[0]
 
+  def GetExternalStorage(self):
+    if not self._external_storage:
+      self._external_storage = self.RunShellCommand('echo $EXTERNAL_STORAGE')[0]
+      assert self._external_storage, 'Unable to find $EXTERNAL_STORAGE'
+    return self._external_storage
+
   def WaitForDevicePm(self):
     """Blocks until the device's package manager is available.
 
     To workaround http://b/5201039, we restart the shell and retry if the
     package manager isn't back after 120 seconds.
 
     Raises:
       errors.WaitForResponseTimedOutError after max retries reached.
     """
     last_err = None
@@ skipping 52 matching lines @@
   def Install(self, package_file_path, reinstall=False):
     """Installs the specified package to the device.
 
     Args:
       package_file_path: Path to .apk file to install.
       reinstall: Reinstall an existing apk, keeping the data.
 
     Returns:
       A status string returned by adb install
     """
-    assert os.path.isfile(package_file_path)
+    assert os.path.isfile(package_file_path), ('<%s> is not file' %
+                                               package_file_path)
 
     install_cmd = ['install']
 
     if reinstall:
       install_cmd.append('-r')
 
     install_cmd.append(package_file_path)
     install_cmd = ' '.join(install_cmd)
 
     logging.info('>>> $' + install_cmd)
@@ skipping 88 matching lines @@
     if not boot_completed:
       raise errors.WaitForResponseTimedOutError(
           'sys.boot_completed flag was not set after %s seconds' % wait_time)
 
   def WaitForSdCardReady(self, timeout_time):
     """Wait for the SD card ready before pushing data into it."""
     logging.info('Waiting for SD card ready...')
     sdcard_ready = False
     attempts = 0
     wait_period = 5
+    external_storage = self.GetExternalStorage()
     while not sdcard_ready and attempts * wait_period < timeout_time:
-      output = self.RunShellCommand('ls /sdcard/')
+      output = self.RunShellCommand('ls ' + external_storage)
       if output:
         sdcard_ready = True
       else:
         time.sleep(wait_period)
         attempts += 1
     if not sdcard_ready:
       raise errors.WaitForResponseTimedOutError(
           'SD card not ready after %s seconds' % timeout_time)
 
   # It is tempting to turn this function into a generator, however this is not
@@ skipping 186 matching lines @@
                          '(?P<user>[^\s]+)\s+'
                          '(?P<group>[^\s]+)\s+'
                          '(?P<size>[^\s]+)\s+'
                          '(?P<date>[^\s]+)\s+'
                          '(?P<time>[^\s]+)\s+'
                          '(?P<filename>[^\s]+)$')
     return _GetFilesFromRecursiveLsOutput(
         path, self.RunShellCommand('ls -lR %s' % path), re_file,
         self._device_utc_offset)
 
-  def SetupPerformanceTest(self):
-    """Sets up performance tests."""
-    # Disable CPU scaling to reduce noise in tests
-    if not self._original_governor:
-      self._original_governor = self.GetFileContents(
-          SCALING_GOVERNOR, log_result=False)
-      self.RunShellCommand('echo performance > ' + SCALING_GOVERNOR)
-    self.DropRamCaches()
-
-  def TearDownPerformanceTest(self):
-    """Tears down performance tests."""
-    if self._original_governor:
-      self.RunShellCommand('echo %s > %s' % (self._original_governor[0],
-                                             SCALING_GOVERNOR))
-    self._original_governor = None
 
   def SetJavaAssertsEnabled(self, enable):
     """Sets or removes the device java assertions property.
 
     Args:
       enable: If True the property will be set.
 
     Returns:
       True if the file was modified (reboot is required for it to take effect).
     """
@@ skipping 17 matching lines @@
     # Next, check the current runtime value is what we need, and
     # if not, set it and report that a reboot is required.
     was_set = 'all' in self.RunShellCommand('getprop ' + JAVA_ASSERT_PROPERTY)
     if was_set == enable:
       return False
 
     self.RunShellCommand('setprop %s "%s"' % (JAVA_ASSERT_PROPERTY,
                                               enable and 'all' or ''))
     return True
 
-  def DropRamCaches(self):
-    """Drops the filesystem ram caches for performance testing."""
-    self.RunShellCommand('echo 3 > ' + DROP_CACHES)
 
   def StartMonitoringLogcat(self, clear=True, timeout=10, logfile=None,
                             filters=None):
     """Starts monitoring the output of logcat, for use with WaitForLogMatch.
 
     Args:
       clear: If True the existing logcat output will be cleared, to avoiding
              matching historical output lurking in the log.
       timeout: How long WaitForLogMatch will wait for the given match
       filters: A list of logcat filters to be used.
@@ skipping 363 matching lines @@
            ' '.join(['-c %s' % c for c in category]),
            '--throttle %d' % throttle,
            '-s %d' % seed,
            '-v ' * verbosity,
            '--monitor-native-crashes',
            '--kill-process-after-error',
            extra_args,
            '%d' % event_count]
     return self.RunShellCommand(' '.join(cmd),
                                 timeout_time=event_count*throttle*1.5)