Run format-webkitpy and fix long lines.

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/port/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 385 matching lines @@
     def _battery_level_for_device(self, commands):
         battery_status = commands.run(['shell', 'dumpsys', 'battery'])
         if 'Error' in battery_status or "Can't find service: battery" in battery_status:
             _log.warning('Unable to read the battery level from device with serial "%s".', commands.get_serial())
             return 0
 
         return int(re.findall(r'level: (\d+)', battery_status)[0])
 
     def _is_device_screen_on(self, commands):
         power_status = commands.run(['shell', 'dumpsys', 'power'])
-        return 'mScreenOn=true' in power_status or 'mScreenOn=SCREEN_ON_BIT' in power_status or 'Display Power: state=ON' in power_status
+        return ('mScreenOn=true' in power_status or
+                'mScreenOn=SCREEN_ON_BIT' in power_status or
+                'Display Power: state=ON' in power_status)
 
 
 class AndroidPort(base.Port):
     port_name = 'android'
 
     # Avoid initializing the adb path [worker count]+1 times by storing it as a static member.
     _adb_path = None
 
     SUPPORTED_VERSIONS = ('android')
 
@@ skipping 23 matching lines @@
 
         # Initialize the AndroidDevices class which tracks available devices.
         default_devices = None
         if hasattr(self._options, 'adb_devices') and len(self._options.adb_devices):
             default_devices = self._options.adb_devices
 
         self._debug_logging = self.get_option('android_logging')
         self._devices = AndroidDevices(default_devices, self._debug_logging)
 
         # 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')])
+        AndroidCommands.set_adb_command_path_options(
+            ['adb', self.path_from_chromium_base('third_party', 'android_tools', 'sdk', 'platform-tools', 'adb')])
 
         prepared_devices = self.get_option('prepared_devices', [])
         for serial in prepared_devices:
             self._devices.set_device_prepared(serial)
 
     def default_smoke_test_only(self):
         return True
 
     # Local public methods.
     def path_to_forwarder(self):
@@ skipping 675 matching lines @@
             self._log_error('Failed to start the content_shell application. Retries=%d. Log:%s' % (retries, self._get_logcat()))
             self.stop()
             time.sleep(2)
         self._abort('Failed to start the content_shell application multiple times. Giving up.')
 
     def _start_once(self, pixel_tests, per_test_args):
         super(ChromiumAndroidDriver, self)._start(pixel_tests, per_test_args, wait_for_ready=False)
 
         self._log_debug('Starting forwarder')
         self._forwarder_process = self._port._server_process_constructor(
-            self._port, 'Forwarder', self._android_commands.adb_command() + ['shell', '%s -no-spawn-daemon %s' % (self._driver_details.device_forwarder_path(), FORWARD_PORTS)])
+            self._port, 'Forwarder', self._android_commands.adb_command() +
+            ['shell', '%s -no-spawn-daemon %s' % (self._driver_details.device_forwarder_path(), FORWARD_PORTS)])
         self._forwarder_process.start()
 
         deadline = time.time() + DRIVER_START_STOP_TIMEOUT_SECS
         if not self._wait_for_server_process_output(self._forwarder_process, deadline, 'Forwarding device port'):
             return False
 
         self._android_commands.run(['logcat', '-c'])
 
         cmd_line_file_path = self._driver_details.command_line_file()
         original_cmd_line_file_path = cmd_line_file_path + '.orig'
         if self._android_commands.file_exists(
                 cmd_line_file_path) and not self._android_commands.file_exists(original_cmd_line_file_path):
             # We check for both the normal path and the backup because we do not want to step
             # on the backup. Otherwise, we'd clobber the backup whenever we changed the
             # command line during the run.
             self._android_commands.run(['shell', 'mv', cmd_line_file_path, original_cmd_line_file_path])
 
-        self._android_commands.run(['shell', 'echo'] + self._android_driver_cmd_line(pixel_tests,
-                                                                                     per_test_args) + ['>', self._driver_details.command_line_file()])
+        self._android_commands.run(
+            ['shell', 'echo'] +
+            self._android_driver_cmd_line(pixel_tests, per_test_args) +
+            ['>', self._driver_details.command_line_file()])
         self._created_cmd_line = True
 
         self._android_commands.run(['shell', 'rm', '-rf', self._driver_details.device_crash_dumps_directory()])
         self._android_commands.mkdir(self._driver_details.device_crash_dumps_directory(), chmod='777')
 
         start_result = self._android_commands.run(
             ['shell', 'am', 'start', '-e', 'RunInSubThread', '-n', self._driver_details.activity_name()])
         if start_result.find('Exception') != -1:
             self._log_error('Failed to start the content_shell application. Exception:\n' + start_result)
             return False
@@ skipping 30 matching lines @@
                 # If normal_startup_event is not set in time, the main thread must be blocked at
                 # reading/writing the fifo. Kill the fifo reading/writing processes to let the
                 # main thread escape from the deadlocked state. After that, the main thread will
                 # treat this as a crash.
                 self._log_error('Deadlock detected. Processes killed.')
                 for i in processes:
                     i.kill()
 
         # Start a thread to kill the pipe reading/writing processes on deadlock of the fifos during startup.
         normal_startup_event = threading.Event()
-        threading.Thread(name='DeadlockDetector', target=deadlock_detector,
-                         args=([self._server_process, self._read_stdout_process, self._read_stderr_process], normal_startup_event)).start()
+        threading.Thread(
+            name='DeadlockDetector',
+            target=deadlock_detector,
+            args=([self._server_process, self._read_stdout_process, self._read_stderr_process], normal_startup_event)).start()
 
         # The test driver might crash during startup or when the deadlock detector hits
         # a deadlock and kills the fifo reading/writing processes.
         if not self._wait_for_server_process_output(self._server_process, deadline, '#READY'):
             return False
 
         # Inform the deadlock detector that the startup is successful without deadlock.
         normal_startup_event.set()
         self._log_debug("content_shell is ready")
         return True
@@ skipping 79 matching lines @@
         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