[Telemetry] Add MeasureMemory method to action_runner

telemetry/telemetry/internal/platform/android_platform_backend.py

 # Copyright 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.
 
 import logging
 import os
 import posixpath
 import re
 import subprocess
 import tempfile
@@ skipping 76 matching lines @@
       try:
         self._device.EnableRoot()
       except device_errors.CommandFailedError:
         logging.warning('Unable to root %s', str(self._device))
     self._battery = battery_utils.BatteryUtils(self._device)
     self._enable_performance_mode = device.enable_performance_mode
     self._surface_stats_collector = None
     self._perf_tests_setup = perf_control.PerfControl(self._device)
     self._thermal_throttle = thermal_throttle.ThermalThrottle(self._device)
     self._raw_display_frame_rate_measurements = []
-    self._can_access_protected_file_contents = (
+    self._can_elevate_privilege = (
         self._device.HasRoot() or self._device.NeedsSU())
     self._device_copy_script = None
     self._power_monitor = (
       android_power_monitor_controller.AndroidPowerMonitorController([
         android_temperature_monitor.AndroidTemperatureMonitor(self._device),
         monsoon_power_monitor.MonsoonPowerMonitor(self._device, self),
         android_dumpsys_power_monitor.DumpsysPowerMonitor(
           self._battery, self),
         sysfs_power_monitor.SysfsPowerMonitor(self, standalone=True),
         android_fuelgauge_power_monitor.FuelGaugePowerMonitor(
@@ skipping 99 matching lines @@
   def CanMonitorThermalThrottling(self):
     return True
 
   def IsThermallyThrottled(self):
     return self._thermal_throttle.IsThrottled()
 
   def HasBeenThermallyThrottled(self):
     return self._thermal_throttle.HasBeenThrottled()
 
   def GetCpuStats(self, pid):
-    if not self._can_access_protected_file_contents:
+    if not self._can_elevate_privilege:
       logging.warning('CPU stats cannot be retrieved on non-rooted device.')
       return {}
     return super(AndroidPlatformBackend, self).GetCpuStats(pid)
 
   def GetCpuTimestamp(self):
-    if not self._can_access_protected_file_contents:
+    if not self._can_elevate_privilege:
       logging.warning('CPU timestamp cannot be retrieved on non-rooted device.')
       return {}
     return super(AndroidPlatformBackend, self).GetCpuTimestamp()
 
   def SetGraphicsMemoryTrackingEnabled(self, enabled):
     if not enabled:
       self.KillApplication('memtrack_helper')
       return
 
     if not android_prebuilt_profiler_helper.InstallOnDevice(
         self._device, 'memtrack_helper'):
       raise Exception('Error installing memtrack_helper.')
     self._device.RunShellCommand([
       android_prebuilt_profiler_helper.GetDevicePath('memtrack_helper'),
       '-d'], as_root=True, check_return=True)
 
   def PurgeUnpinnedMemory(self):
     """Purges the unpinned ashmem memory for the whole system.
 
     This can be used to make memory measurements more stable. Requires root.
     """
-    if not self._can_access_protected_file_contents:
+    if not self._can_elevate_privilege:
       logging.warning('Cannot run purge_ashmem. Requires a rooted device.')
       return
 
     if not android_prebuilt_profiler_helper.InstallOnDevice(
         self._device, 'purge_ashmem'):
       raise Exception('Error installing purge_ashmem.')
     output = self._device.RunShellCommand([
       android_prebuilt_profiler_helper.GetDevicePath('purge_ashmem')])
     for l in output:
       logging.info(l)
@@ skipping 37 matching lines @@
     return self._device.product_model
 
   @decorators.Cache
   def GetOSVersionName(self):
     return self._device.GetProp('ro.build.id')[0]
 
   def CanFlushIndividualFilesFromSystemCache(self):
     return False
 
   def FlushEntireSystemCache(self):
+    if not self._can_elevate_privilege:
+      logging.warning('Cannot flush system cache on non-rooted device.')
+      return
     cache = cache_control.CacheControl(self._device)
     cache.DropRamCaches()
 
   def FlushSystemCacheForDirectory(self, directory):
     raise NotImplementedError()
 
   def FlushDnsCache(self):
     self._device.RunShellCommand(
         ['ndc', 'resolver', 'flushdefaultif'], as_root=True)
 
   def StopApplication(self, application):
     """Stop the given |application|.
 
     Args:
        application: The full package name string of the application to stop.
     """
     self._device.ForceStop(application)
 
   def KillApplication(self, application):
     """Kill the given |application|.
 
     Might be used instead of ForceStop for efficiency reasons.
 
     Args:
       application: The full package name string of the application to kill.
     """
     assert isinstance(application, basestring)
     self._device.KillAll(application, blocking=True, quiet=True)
 
+  def CanElevatePrivilege(self):
+    return self._can_elevate_privilege
+
   def LaunchApplication(
       self, application, parameters=None, elevate_privilege=False):
     """Launches the given |application| with a list of |parameters| on the OS.
 
     Args:
       application: The full package name string of the application to launch.
       parameters: A list of parameters to be passed to the ActivityManager.
       elevate_privilege: Currently unimplemented on Android.
     """
     if elevate_privilege:
@@ skipping 67 matching lines @@
 
   def PathExists(self, device_path, timeout=None, retries=None):
     """ Return whether the given path exists on the device.
     This method is the same as
     devil.android.device_utils.DeviceUtils.PathExists.
     """
     return self._device.PathExists(
         device_path, timeout=timeout, retries=retries)
 
   def GetFileContents(self, fname):
-    if not self._can_access_protected_file_contents:
+    if not self._can_elevate_privilege:
       logging.warning('%s cannot be retrieved on non-rooted device.', fname)
       return ''
     return self._device.ReadFile(fname, as_root=True)
 
   def GetPsOutput(self, columns, pid=None):
     assert columns == ['pid', 'name'] or columns == ['pid'], \
         'Only know how to return pid and name. Requested: ' + columns
     cmd = ['ps']
     if pid:
       cmd.extend(['-p', str(pid)])
@@ skipping 323 matching lines @@
   for process in psutil.process_iter():
     try:
       if psutil.version_info >= (2, 0):
         if 'adb' in process.name():
           process.cpu_affinity([0])
       else:
         if 'adb' in process.name:
           process.set_cpu_affinity([0])
     except (psutil.NoSuchProcess, psutil.AccessDenied):
       logging.warn('Failed to set adb process CPU affinity')