Only consider Android devices with more than 30% battery remaining for layout tests

Tools/Scripts/webkitpy/layout_tests/port/chromium_android.py

 # Copyright (C) 2012 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 257 matching lines @@
                 continue
 
             command_path = path_option
             command_version = path_version
 
         assert command_path, 'Unable to locate the "adb" command. Are you using an Android checkout of Chromium?'
 
         AndroidCommands._adb_command_path = command_path
         return command_path
 
-    @staticmethod
-    def get_devices(executive):
-        re_device = re.compile('^([a-zA-Z0-9_:.-]+)\tdevice$', re.MULTILINE)
-        result = executive.run_command([AndroidCommands.adb_command_path(executive), 'devices'],
-                error_handler=executive.ignore_error)
-        devices = re_device.findall(result)
-        if not devices:
-            raise AssertionError('No devices attached. Result of "adb devices": %s' % result)
-
-        return devices
-
     # Local private methods.
 
     def _log_error(self, message):
         _log.error('[%s] %s' % (self._device_serial, message))
 
     def _log_debug(self, message):
         _log.debug('[%s] %s' % (self._device_serial, message))
 
     @staticmethod
     def _determine_adb_version(adb_command_path, executive):
         re_version = re.compile('^.*version ([\d\.]+)$')
         try:
             output = executive.run_command([adb_command_path, 'version'], error_handler=executive.ignore_error)
         except OSError:
             return None
 
         result = re_version.match(output)
         if not output or not result:
             return None
 
         return [int(n) for n in result.group(1).split('.')]
 
+
+# A class to encapsulate device status and information, such as the AndroidCommands
+# instances and whether the device has been set up.
+class AndroidDevices(object):
+    # Percentage of battery a device needs to have in order for it to be considered
+    # to participate in running the layout tests.
+    MINIMUM_BATTERY_PERCENTAGE = 30
+
+    def __init__(self, executive, default_device=None):
+        self._usable_devices = []
+        self._default_device = default_device
+        self._prepared_devices = []
+
+    def usable_devices(self, executive):
+        if self._usable_devices:
+            return self._usable_devices
+
+        if self._default_device:
+            self._usable_devices = [AndroidCommands(executive, self._default_device)]
+            return self._usable_devices
+
+        # Example "adb devices" command output:
+        #   List of devices attached
+        #   0123456789ABCDEF        device
+        re_device = re.compile('^([a-zA-Z0-9_:.-]+)\tdevice$', re.MULTILINE)
+
+        result = executive.run_command([AndroidCommands.adb_command_path(executive), 'devices'],
+                error_handler=executive.ignore_error)
+        devices = re_device.findall(result)
+        if not devices:
+            raise AssertionError('Unable to find attached Android devices. ADB output: %s' % result)
+
+        for device_serial in devices:
+            commands = AndroidCommands(executive, device_serial)
+            if self._battery_level_for_device(commands) < AndroidDevices.MINIMUM_BATTERY_PERCENTAGE:
+                continue
+
+            self._usable_devices.append(commands)
+
+        if not self._usable_devices:
+            raise AssertionError('No devices attached with more than %d percent battery.' %
+                AndroidDevices.MINIMUM_BATTERY_PERCENTAGE)
+
+        return self._usable_devices
+
+    def get_device(self, executive, device_index):
+        devices = self.usable_devices(executive)
+        if device_index >= len(devices):
+            raise AssertionError('Device index exceeds number of usable devices.')
+
+        return devices[device_index]
+
+    def is_device_prepared(self, device_serial):
+        return device_serial in self._prepared_devices
+
+    def set_device_prepared(self, device_serial):
+        self._prepared_devices.append(device_serial)
+
+    # Private methods
+    def _battery_level_for_device(self, commands):
+        battery_status = commands.run(['shell', 'dumpsys', 'battery'])
+        if 'Error' in battery_status:
+            _log.warning('Unable to read the battery level from device with serial "%s".' % commands.get_serial())
+            return 100
+
+        return int(re.findall('level: (\d+)', battery_status)[0])
+
+
 class ChromiumAndroidPort(chromium.ChromiumPort):
     port_name = 'chromium-android'
 
     # Avoid initializing the adb path [worker count]+1 times by storing it as a static member.
     _adb_path = None
 
     SUPPORTED_VERSIONS = ('android')
 
     FALLBACK_PATHS = { 'android': [ 'chromium-android' ] + chromium_linux.ChromiumLinuxPort.latest_platform_fallback_path() }
 
     def __init__(self, host, port_name, **kwargs):
         super(ChromiumAndroidPort, self).__init__(host, port_name, **kwargs)
 
         self._operating_system = 'android'
         self._version = 'icecreamsandwich'
 
         self._host_port = factory.PortFactory(host).get('chromium', **kwargs)
         self._server_process_constructor = self._android_server_process_constructor
 
         if self.driver_name() == 'content_shell':
             self._driver_details = ContentShellDriverDetails()
         else:
             self._driver_details = DumpRenderTreeDriverDetails()
 
+        # Initialize the AndroidDevices class which tracks available devices.
+        default_device = None
         if hasattr(self._options, 'adb_device') and len(self._options.adb_device):
-            self._devices = [self._options.adb_device]
-        else:
-            self._devices = []
+            default_device = self._options.adb_device
 
+        self._devices = AndroidDevices(self._executive, default_device)
+
+        # Tell AndroidCommands where to search for the "adb" command.
         AndroidCommands.set_adb_command_path_options(['adb',
             self.path_from_chromium_base('third_party', 'android_tools', 'sdk', 'platform-tools', 'adb')])
 
     # Local public methods.
-    def get_device_serial(self, worker_number):
-        if not self._devices:
-            self._devices = AndroidCommands.get_devices(self._executive)
-        if worker_number >= len(self._devices):
-            raise AssertionError('Worker number exceeds available number of devices')
-        return self._devices[worker_number]
-
     def path_to_forwarder(self):
         return self._build_path('forwarder')
 
     def path_to_md5sum(self):
         return self._build_path(MD5SUM_DEVICE_FILE_NAME)
 
     def path_to_md5sum_host(self):
         return self._build_path(MD5SUM_HOST_FILE_NAME)
 
     # Overridden public methods.
@@ skipping 19 matching lines @@
         return 0.0
 
     def driver_name(self):
         if self.get_option('driver_name'):
             return self.get_option('driver_name')
         if self.get_option('content_shell'):
             return self.CONTENT_SHELL_NAME
         return 'DumpRenderTree'
 
     def default_child_processes(self):
-        if self._devices:
-            return len(self._devices)
+        usable_device_count = len(self._devices.usable_devices(self._executive))
+        if not usable_device_count:
+            raise AssertionError('There are no devices available to run the layout tests on.')
 
-        return len(AndroidCommands.get_devices(self._executive))
+        return usable_device_count
 
     def default_baseline_search_path(self):
         return map(self._webkit_baseline_path, self.FALLBACK_PATHS['android'])
 
     def check_wdiff(self, logging=True):
         return self._host_port.check_wdiff(logging)
 
     def check_build(self, needs_http):
         result = super(ChromiumAndroidPort, self).check_build(needs_http)
         result = self._check_file_exists(self.path_to_md5sum(), 'md5sum utility') and result
@@ skipping 25 matching lines @@
         return True
 
     def start_http_server(self, additional_dirs=None, number_of_servers=0):
         if not additional_dirs:
             additional_dirs = {}
         additional_dirs[PERF_TEST_PATH_PREFIX] = self.perf_tests_dir()
         additional_dirs[LAYOUT_TEST_PATH_PREFIX] = self.layout_tests_dir()
         super(ChromiumAndroidPort, self).start_http_server(additional_dirs, number_of_servers)
 
     def create_driver(self, worker_number, no_timeout=False):
-        return ChromiumAndroidDriver(self, worker_number, pixel_tests=self.get_option('pixel_tests'), driver_details=self._driver_details,
+        return ChromiumAndroidDriver(self, worker_number, pixel_tests=self.get_option('pixel_tests'),
+                                     driver_details=self._driver_details,
+                                     android_devices=self._devices,
                                      # Force no timeout to avoid test driver timeouts before NRWT.
                                      no_timeout=True)
 
     def driver_cmd_line(self):
         # Override to return the actual test driver's command line.
         return self.create_driver(0)._android_driver_cmd_line(self.get_option('pixel_tests'), [])
 
     # Overridden protected methods.
 
     def _port_specific_expectations_files(self):
@@ skipping 164 matching lines @@
 for instructions on installing pre-built copies of perfhost_linux
 http://crbug.com/165250 discusses making these pre-built binaries externally available.
 """
 
         perfhost_display_patch = perfhost_path if perfhost_path else 'perfhost_linux'
         print "To view the full profile, run:"
         print ' '.join([perfhost_display_patch] + perfhost_report_command)
 
 
 class ChromiumAndroidDriver(driver.Driver):
-    def __init__(self, port, worker_number, pixel_tests, driver_details, no_timeout=False):
+    def __init__(self, port, worker_number, pixel_tests, driver_details, android_devices, no_timeout=False):
         super(ChromiumAndroidDriver, self).__init__(port, worker_number, pixel_tests, no_timeout)
         self._in_fifo_path = driver_details.device_fifo_directory() + 'stdin.fifo'
         self._out_fifo_path = driver_details.device_fifo_directory() + 'test.fifo'
         self._err_fifo_path = driver_details.device_fifo_directory() + 'stderr.fifo'
         self._read_stdout_process = None
         self._read_stderr_process = None
         self._forwarder_process = None
-        self._has_setup = False
         self._original_governors = {}
         self._original_kptr_restrict = None
 
-        self._android_commands = AndroidCommands(port._executive, port.get_device_serial(worker_number))
+        self._android_devices = android_devices
+        self._android_commands = android_devices.get_device(port._executive, worker_number)
         self._driver_details = driver_details
 
         # FIXME: If we taught ProfileFactory about "target" devices we could
         # just use the logic in Driver instead of duplicating it here.
         if self._port.get_option("profile"):
             # FIXME: This should be done once, instead of per-driver!
             symfs_path = self._find_or_create_symfs()
             kallsyms_path = self._update_kallsyms_cache(symfs_path)
             # FIXME: We should pass this some sort of "Bridge" object abstraction around ADB instead of a path/device pair.
             self._profiler = AndroidPerf(self._port.host, self._port._path_to_driver(), self._port.results_directory(),
@@ skipping 56 matching lines @@
         if not self._android_commands.file_exists(MD5SUM_DEVICE_PATH):
             if not self._android_commands.push(self._md5sum_path, MD5SUM_DEVICE_PATH):
                 raise AssertionError('Could not push md5sum to device')
 
         self._push_executable()
         self._push_fonts()
         self._push_test_resources()
         self._push_platform_resources()
 
     def _setup_test(self):
-        if self._has_setup:
+        if self._android_devices.is_device_prepared(self._android_commands.get_serial()):
             return
 
         self._android_commands.restart_as_root()
         self._setup_md5sum_and_push_data_if_needed()
-        self._has_setup = True
         self._setup_performance()
 
         # Required by webkit_support::GetWebKitRootDirFilePath().
         # Other directories will be created automatically by adb push.
         self._android_commands.mkdir(DEVICE_SOURCE_ROOT_DIR + 'chrome')
 
         # Allow the test driver to get full read and write access to the directory on the device,
         # as well as for the FIFOs. We'll need a world writable directory.
         self._android_commands.mkdir(self._driver_details.device_directory(), chmod='777')
         self._android_commands.mkdir(self._driver_details.device_fifo_directory(), chmod='777')
 
         # Make sure that the disk cache on the device resets to a clean state.
         self._android_commands.run(['shell', 'rm', '-r', self._driver_details.device_cache_directory()])
 
+        # Mark this device as having been set up.
+        self._android_devices.set_device_prepared(self._android_commands.get_serial())
+
     def _log_error(self, message):
         _log.error('[%s] %s' % (self._android_commands.get_serial(), message))
 
     def _log_debug(self, message):
         _log.debug('[%s] %s' % (self._android_commands.get_serial(), message))
 
     def _abort(self, message):
         raise AssertionError('[%s] %s' % (self._android_commands.get_serial(), message))
 
     @staticmethod
@@ skipping 258 matching lines @@
         if self._read_stderr_process:
             self._read_stderr_process.kill()
             self._read_stderr_process = None
 
         super(ChromiumAndroidDriver, self).stop()
 
         if self._forwarder_process:
             self._forwarder_process.kill()
             self._forwarder_process = None
 
-        if self._has_setup:
+        if self._android_devices.is_device_prepared(self._android_commands.get_serial()):
             if not ChromiumAndroidDriver._loop_with_timeout(self._remove_all_pipes, DRIVER_START_STOP_TIMEOUT_SECS):
                 raise AssertionError('Failed to remove fifo files. May be locked.')
 
     def _command_from_driver_input(self, driver_input):
         command = super(ChromiumAndroidDriver, self)._command_from_driver_input(driver_input)
         if command.startswith('/'):
             fs = self._port._filesystem
             # FIXME: what happens if command lies outside of the layout_tests_dir on the host?
             relative_test_filename = fs.relpath(command, fs.dirname(self._port.layout_tests_dir()))
             command = DEVICE_WEBKIT_BASE_DIR + relative_test_filename
         return command
 
     def _read_prompt(self, deadline):
         last_char = ''
         while True:
             current_char = self._server_process.read_stdout(deadline, 1)
             if current_char == ' ':
                 if last_char in ('#', '$'):
                     return
             last_char = current_char