Run yapf on files in webkit/layout_tests/.

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 103 matching lines @@
     [[MS_TRUETYPE_FONTS_DIR], 'Verdana_Italic.ttf', MS_TRUETYPE_FONTS_PACKAGE],
     # The Microsoft font EULA
     [['/usr/share/doc/ttf-mscorefonts-installer/'], 'READ_ME!.gz', MS_TRUETYPE_FONTS_PACKAGE],
     # Other fonts: Arabic, CJK, Indic, Thai, etc.
     [['/usr/share/fonts/truetype/ttf-dejavu/'], 'DejaVuSans.ttf', 'ttf-dejavu'],
     [['/usr/share/fonts/truetype/kochi/'], 'kochi-mincho.ttf', 'ttf-kochi-mincho'],
     [['/usr/share/fonts/truetype/ttf-indic-fonts-core/'], 'lohit_hi.ttf', 'ttf-indic-fonts-core'],
     [['/usr/share/fonts/truetype/ttf-indic-fonts-core/'], 'lohit_ta.ttf', 'ttf-indic-fonts-core'],
     [['/usr/share/fonts/truetype/ttf-indic-fonts-core/'], 'MuktiNarrow.ttf', 'ttf-indic-fonts-core'],
     [['/usr/share/fonts/truetype/thai/', '/usr/share/fonts/truetype/tlwg/'], 'Garuda.ttf', 'fonts-tlwg-garuda'],
-    [['/usr/share/fonts/truetype/ttf-indic-fonts-core/', '/usr/share/fonts/truetype/ttf-punjabi-fonts/'], 'lohit_pa.ttf', 'ttf-indic-fonts-core'],
+    [['/usr/share/fonts/truetype/ttf-indic-fonts-core/', '/usr/share/fonts/truetype/ttf-punjabi-fonts/'], 'lohit_pa.ttf',
+     'ttf-indic-fonts-core'],
 ]
 
 # Test resources that need to be accessed as files directly.
 # Each item can be the relative path of a directory or a file.
 TEST_RESOURCES_TO_PUSH = [
     # Blob tests need to access files directly.
     'editing/pasteboard/resources',
     'fast/files/resources',
     'http/tests/local/resources',
     'http/tests/local/formdata/resources',
@@ skipping 112 matching lines @@
                 pass
         return pids
 
     def run(self, command, ignore_error=False):
         self._log_debug('Run adb command: ' + str(command))
         if ignore_error:
             error_handler = self._executive.ignore_error
         else:
             error_handler = None
 
-        result = self._executive.run_command(self.adb_command() + command, error_handler=error_handler, debug_logging=self._debug_logging)
+        result = self._executive.run_command(self.adb_command() + command,
+                                             error_handler=error_handler,
+                                             debug_logging=self._debug_logging)
 
         # We limit the length to avoid outputting too verbose commands, such as "adb logcat".
         self._log_debug('Run adb result: ' + result[:80])
         return result
 
     def get_serial(self):
         return self._device_serial
 
     def adb_command(self):
         return [AndroidCommands.adb_command_path(self._executive, self._debug_logging), '-s', self._device_serial]
@@ skipping 35 matching lines @@
         _log.info('[%s] %s' % (self._device_serial, message))
 
     def _log_debug(self, message):
         if self._debug_logging:
             _log.debug('[%s] %s' % (self._device_serial, message))
 
     @staticmethod
     def _determine_adb_version(adb_command_path, executive, debug_logging):
         re_version = re.compile('^.*version ([\d\.]+)')
         try:
-            output = executive.run_command([adb_command_path, 'version'], error_handler=executive.ignore_error,
+            output = executive.run_command([adb_command_path, 'version'],
+                                           error_handler=executive.ignore_error,
                                            debug_logging=debug_logging)
         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('.')]
 
@@ skipping 20 matching lines @@
 
         if self._default_device:
             self._usable_devices = [AndroidCommands(executive, self._default_device, self._debug_logging)]
             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, debug_logging=self._debug_logging), 'devices'],
-                                       error_handler=executive.ignore_error, debug_logging=self._debug_logging)
+        result = executive.run_command(
+            [AndroidCommands.adb_command_path(executive,
+                                              debug_logging=self._debug_logging), 'devices'],
+            error_handler=executive.ignore_error,
+            debug_logging=self._debug_logging)
         devices = re_device.findall(result)
         if not devices:
             return []
 
         for device_serial in sorted(devices):
             commands = AndroidCommands(executive, device_serial, self._debug_logging)
             if self._battery_level_for_device(commands) < AndroidDevices.MINIMUM_BATTERY_PERCENTAGE:
-                _log.warning('Device with serial "%s" skipped because it has less than %d percent battery.'
-                    % (commands.get_serial(), AndroidDevices.MINIMUM_BATTERY_PERCENTAGE))
+                _log.warning('Device with serial "%s" skipped because it has less than %d percent battery.' %
+                             (commands.get_serial(), AndroidDevices.MINIMUM_BATTERY_PERCENTAGE))
                 continue
 
             if not self._is_device_screen_on(commands):
                 _log.warning('Device with serial "%s" skipped because the screen must be on.' % commands.get_serial())
                 continue
 
             self._usable_devices.append(commands)
 
         return self._usable_devices
 
@@ skipping 58 matching lines @@
 
         # Initialize the AndroidDevices class which tracks available devices.
         default_device = None
         if hasattr(self._options, 'adb_device') and len(self._options.adb_device):
             default_device = self._options.adb_device
 
         self._debug_logging = self.get_option('android_logging')
         self._devices = AndroidDevices(self._executive, default_device, 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):
         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)
 
     def additional_driver_flag(self):
-        return super(AndroidPort, self).additional_driver_flag() + self._driver_details.additional_command_line_flags(use_breakpad=not self.get_option('disable_breakpad'))
+        return super(AndroidPort, self).additional_driver_flag() + self._driver_details.additional_command_line_flags(
+            use_breakpad=not self.get_option('disable_breakpad'))
 
     def default_timeout_ms(self):
         # Android platform has less computing power than desktop platforms.
         # Using 10 seconds allows us to pass most slow tests which are not
         # marked as slow tests on desktop platforms.
         return 10 * 1000
 
     def driver_stop_timeout(self):
         # The driver doesn't respond to closing stdin, so we might as well stop the driver immediately.
         return 0.0
 
     def default_child_processes(self):
         usable_devices = self._devices.usable_devices(self._executive)
         if not usable_devices:
-            raise test_run_results.TestRunException(test_run_results.NO_DEVICES_EXIT_STATUS, "Unable to find any attached Android devices.")
+            raise test_run_results.TestRunException(test_run_results.NO_DEVICES_EXIT_STATUS,
+                                                    "Unable to find any attached Android devices.")
         return len(usable_devices)
 
     def max_drivers_per_process(self):
         # Android falls over when we try to run multiple content_shells per worker.
         # See https://codereview.chromium.org/1158323009/
         return 1
 
     def check_wdiff(self, logging=True):
         return self._host_port.check_wdiff(logging)
 
@@ skipping 102 matching lines @@
 
     def check_sys_deps(self, needs_http):
         for (font_dirs, font_file, package) in HOST_FONT_FILES:
             exists = False
             for font_dir in font_dirs:
                 font_path = font_dir + font_file
                 if self._check_file_exists(font_path, '', logging=False):
                     exists = True
                     break
             if not exists:
-                _log.error('You are missing %s under %s. Try installing %s. See build instructions.' % (font_file, font_dirs, package))
+                _log.error('You are missing %s under %s. Try installing %s. See build instructions.' %
+                           (font_file, font_dirs, package))
                 return test_run_results.SYS_DEPS_EXIT_STATUS
         return test_run_results.OK_EXIT_STATUS
 
     def requires_http_server(self):
         """Chromium Android runs tests on devices, and uses the HTTP server to
         serve the actual layout tests to the test driver."""
         return True
 
     def start_http_server(self, additional_dirs, number_of_drivers):
         additional_dirs[PERF_TEST_PATH_PREFIX] = self.perf_tests_dir()
         additional_dirs[LAYOUT_TEST_PATH_PREFIX] = self.layout_tests_dir()
         super(AndroidPort, self).start_http_server(additional_dirs, number_of_drivers)
 
     def create_driver(self, worker_number, no_timeout=False):
-        return ChromiumAndroidDriver(self, worker_number, pixel_tests=self.get_option('pixel_tests'),
+        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'), [])
 
     def clobber_old_port_specific_results(self):
@@ skipping 35 matching lines @@
     # Local private methods.
 
     @staticmethod
     def _android_server_process_constructor(port, server_name, cmd_line, env=None, logging=False):
         # We need universal_newlines=True, because 'adb shell' for some unknown reason
         # does newline conversion of unix-style LF into win-style CRLF (and we need
         # to convert that back). This can cause headaches elsewhere because
         # server_process' stdout and stderr are now unicode file-like objects,
         # not binary file-like objects like all of the other ports are.
         # FIXME: crbug.com/496983.
-        return server_process.ServerProcess(port, server_name, cmd_line, env,
-                                            universal_newlines=True, treat_no_data_as_crash=True, logging=logging)
+        return server_process.ServerProcess(port,
+                                            server_name,
+                                            cmd_line,
+                                            env,
+                                            universal_newlines=True,
+                                            treat_no_data_as_crash=True,
+                                            logging=logging)
 
 
 class AndroidPerf(SingleFileOutputProfiler):
     _cached_perf_host_path = None
     _have_searched_for_perf_host = False
 
     def __init__(self, host, executable_path, output_dir, android_commands, symfs_path, kallsyms_path, identifier=None):
         super(AndroidPerf, self).__init__(host, executable_path, output_dir, "data", identifier)
         self._android_commands = android_commands
         self._perf_process = None
@@ skipping 29 matching lines @@
 The test driver must be built with profiling=1, make sure you've done:
 export GYP_DEFINES="profiling=1 $GYP_DEFINES"
 update-webkit --chromium-android
 build-webkit --chromium-android
 
 Googlers should read:
 http://goto.google.com/cr-android-perf-howto
 """)
 
     def attach_to_pid(self, pid):
-        assert(pid)
-        assert(self._perf_process == None)
+        assert (pid)
+        assert (self._perf_process is None)
         # FIXME: This can't be a fixed timeout!
         cmd = self._android_commands.adb_command() + ['shell', 'perf', 'record', '-g', '-p', pid, 'sleep', 30]
         self._perf_process = self._host.executive.popen(cmd)
 
     def _perf_version_string(self, perf_path):
         try:
             return self._host.executive.run_command([perf_path, '--version'])
         except:
             return None
 
@@ skipping 21 matching lines @@
         perf_exitcode = self._perf_process.wait()
         if perf_exitcode != 0:
             _log.debug("Perf failed (exit code: %i), can't process results." % perf_exitcode)
             return
 
         self._android_commands.pull('/data/perf.data', self._output_path)
 
         perfhost_path = self._perfhost_path()
         perfhost_report_command = [
             'report',
-            '--input', self._output_path,
-            '--symfs', self._symfs_path,
-            '--kallsyms', self._kallsyms_path,
+            '--input',
+            self._output_path,
+            '--symfs',
+            self._symfs_path,
+            '--kallsyms',
+            self._kallsyms_path,
         ]
         if perfhost_path:
             perfhost_args = [perfhost_path] + perfhost_report_command + ['--call-graph', 'none']
             perf_output = self._host.executive.run_command(perfhost_args)
             # We could save off the full -g report to a file if users found that useful.
             _log.debug(self._first_ten_lines_of_profile(perf_output))
         else:
             _log.debug("""
 Failed to find perfhost_linux binary, can't process samples from the device.
 
 perfhost_linux can be built from:
 https://android.googlesource.com/platform/external/linux-tools-perf/
 also, modern versions of perf (available from apt-get install goobuntu-kernel-tools-common)
 may also be able to process the perf.data files from the device.
 
 Googlers should read:
 http://goto.google.com/cr-android-perf-howto
 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'
         _log.debug("To view the full profile, run:")
         _log.debug(' '.join([perfhost_display_patch] + perfhost_report_command))
 
 
 class ChromiumAndroidDriver(driver.Driver):
-
     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._original_governors = {}
         self._original_kptr_restrict = None
 
         self._android_devices = android_devices
         self._android_commands = android_devices.get_device(port._executive, worker_number)
         self._driver_details = driver_details
         self._debug_logging = self._port._debug_logging
         self._created_cmd_line = False
         self._device_failed = False
 
         # 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(),
-                self._android_commands, symfs_path, kallsyms_path)
+                                         self._android_commands, symfs_path, kallsyms_path)
             # FIXME: This is a layering violation and should be moved to Port.check_sys_deps
             # once we have an abstraction around an adb_path/device_serial pair to make it
             # easy to make these class methods on AndroidPerf.
             if not self._profiler.check_configuration():
                 self._profiler.print_setup_instructions()
                 sys.exit(1)
         else:
             self._profiler = None
 
     def __del__(self):
@@ skipping 23 matching lines @@
         fs = self._port.host.filesystem
 
         if 'ANDROID_SYMFS' in env:
             symfs_path = env['ANDROID_SYMFS']
         else:
             symfs_path = fs.join(self._port.results_directory(), 'symfs')
             _log.debug("ANDROID_SYMFS not set, using %s" % symfs_path)
 
         # find the installed path, and the path of the symboled built library
         # FIXME: We should get the install path from the device!
-        symfs_library_path = fs.join(symfs_path, "data/app-lib/%s-1/%s" % (self._driver_details.package_name(), self._driver_details.library_name()))
+        symfs_library_path = fs.join(symfs_path, "data/app-lib/%s-1/%s" %
+                                     (self._driver_details.package_name(), self._driver_details.library_name()))
         built_library_path = self._port._build_path('lib', self._driver_details.library_name())
-        assert(fs.exists(built_library_path))
+        assert (fs.exists(built_library_path))
 
         # FIXME: Ideally we'd check the sha1's first and make a soft-link instead of copying (since we probably never care about windows).
         _log.debug("Updating symfs library (%s) from built copy (%s)" % (symfs_library_path, built_library_path))
         fs.maybe_make_directory(fs.dirname(symfs_library_path))
         fs.copyfile(built_library_path, symfs_library_path)
 
         return symfs_path
 
     def _setup_md5sum_and_push_data_if_needed(self, log_callback):
         self._md5sum_path = self._port.path_to_md5sum()
@@ skipping 47 matching lines @@
         self._device_failed = True
         raise driver.DeviceFailure('[%s] %s' % (self._android_commands.get_serial(), message))
 
     @staticmethod
     def _extract_hashes_from_md5sum_output(md5sum_output):
         assert md5sum_output
         return [line.split('  ')[0] for line in md5sum_output]
 
     def _files_match(self, host_file, device_file):
         assert self._port.host.filesystem.exists(host_file)
-        device_hashes = self._extract_hashes_from_md5sum_output(
-                self._port.host.executive.popen(self._android_commands.adb_command() + ['shell', MD5SUM_DEVICE_PATH, device_file],
-                                                stdout=subprocess.PIPE).stdout)
-        host_hashes = self._extract_hashes_from_md5sum_output(
-                self._port.host.executive.popen(args=['%s_host' % self._md5sum_path, host_file],
-                                                stdout=subprocess.PIPE).stdout)
+        device_hashes = self._extract_hashes_from_md5sum_output(self._port.host.executive.popen(self._android_commands.adb_command() +
+                                                                                                ['shell', MD5SUM_DEVICE_PATH, device_file],
+                                                                                                stdout=subprocess.PIPE).stdout)
+        host_hashes = self._extract_hashes_from_md5sum_output(self._port.host.executive.popen(args=['%s_host' % self._md5sum_path,
+                                                                                                    host_file],
+                                                                                              stdout=subprocess.PIPE).stdout)
         return host_hashes and device_hashes == host_hashes
 
     def _push_file_if_needed(self, host_file, device_file, log_callback):
         basename = self._port.host.filesystem.basename(host_file)
         log_callback("checking %s" % basename)
         if not self._files_match(host_file, device_file):
             log_callback("pushing %s" % basename)
             self._android_commands.push(host_file, device_file)
 
     def _push_executable(self, log_callback):
         self._push_file_if_needed(self._port.path_to_forwarder(), self._driver_details.device_forwarder_path(), log_callback)
         for resource in self._driver_details.additional_resources():
-            self._push_file_if_needed(self._port._build_path(resource), self._driver_details.device_directory() + resource, log_callback)
+            self._push_file_if_needed(
+                self._port._build_path(resource), self._driver_details.device_directory() + resource, log_callback)
 
-        self._push_file_if_needed(self._port._build_path('android_main_fonts.xml'), self._driver_details.device_directory() + 'android_main_fonts.xml', log_callback)
-        self._push_file_if_needed(self._port._build_path('android_fallback_fonts.xml'), self._driver_details.device_directory() + 'android_fallback_fonts.xml', log_callback)
+        self._push_file_if_needed(
+            self._port._build_path('android_main_fonts.xml'), self._driver_details.device_directory() + 'android_main_fonts.xml',
+            log_callback)
+        self._push_file_if_needed(
+            self._port._build_path('android_fallback_fonts.xml'),
+            self._driver_details.device_directory() + 'android_fallback_fonts.xml', log_callback)
 
         log_callback("checking apk")
-        if self._files_match(self._port._build_path('apks', 'ContentShell.apk'),
-                             '/data/app/org.chromium.content_shell_apk-1.apk'):
+        if self._files_match(self._port._build_path('apks', 'ContentShell.apk'), '/data/app/org.chromium.content_shell_apk-1.apk'):
             return
 
         log_callback("uninstalling apk")
         self._android_commands.run(['uninstall', self._driver_details.package_name()])
         driver_host_path = self._port._path_to_driver()
         log_callback("installing apk")
         install_result = self._android_commands.run(['install', driver_host_path])
         if install_result.find('Success') == -1:
             self._abort('Failed to install %s onto device: %s' % (driver_host_path, install_result))
 
     def _push_fonts(self, log_callback):
         path_to_ahem_font = self._port._build_path('AHEM____.TTF')
         self._push_file_if_needed(path_to_ahem_font, self._driver_details.device_fonts_directory() + 'AHEM____.TTF', log_callback)
         for (host_dirs, font_file, package) in HOST_FONT_FILES:
             for host_dir in host_dirs:
                 host_font_path = host_dir + font_file
                 if self._port._check_file_exists(host_font_path, '', logging=False):
-                    self._push_file_if_needed(host_font_path, self._driver_details.device_fonts_directory() + font_file, log_callback)
+                    self._push_file_if_needed(host_font_path, self._driver_details.device_fonts_directory() + font_file,
+                                              log_callback)
 
     def _push_test_resources(self, log_callback):
         for resource in TEST_RESOURCES_TO_PUSH:
-            self._push_file_if_needed(self._port.layout_tests_dir() + '/' + resource, DEVICE_LAYOUT_TESTS_DIR + resource, log_callback)
+            self._push_file_if_needed(self._port.layout_tests_dir() + '/' + resource, DEVICE_LAYOUT_TESTS_DIR + resource,
+                                      log_callback)
 
     def _get_last_stacktrace(self):
         tombstones = self._android_commands.run(['shell', 'ls', '-n', '/data/tombstones/tombstone_*'])
         if not tombstones or tombstones.startswith('/data/tombstones/tombstone_*: No such file or directory'):
             self._log_error('The driver crashed, but no tombstone found!')
             return ''
 
         if tombstones.startswith('/data/tombstones/tombstone_*: Permission denied'):
             # FIXME: crbug.com/321489 ... figure out why this happens.
             self._log_error('The driver crashed, but we could not read the tombstones!')
@@ skipping 47 matching lines @@
         if not stdout:
             stdout = ''
         stdout += '********* [%s] Logcat:\n%s' % (self._android_commands.get_serial(), self._get_logcat())
         if not stderr:
             stderr = ''
         stderr += '********* [%s] Tombstone file:\n%s' % (self._android_commands.get_serial(), self._get_last_stacktrace())
 
         if not self._port.get_option('disable_breakpad'):
             crashes = self._pull_crash_dumps_from_device()
             for crash in crashes:
-                stderr += '********* [%s] breakpad minidump %s:\n%s' % (self._port.host.filesystem.basename(crash), self._android_commands.get_serial(), self._port._dump_reader._get_stack_from_dump(crash))
+                stderr += '********* [%s] breakpad minidump %s:\n%s' % (self._port.host.filesystem.basename(crash),
+                                                                        self._android_commands.get_serial(),
+                                                                        self._port._dump_reader._get_stack_from_dump(crash))
 
         # The parent method expects stdout and stderr to be byte streams, but
         # since adb shell does newline conversion, we used universal_newlines
         # when launching the processes, and hence our stdout and stderr are
         # text objects that need to be encoded back into bytes.
         return super(ChromiumAndroidDriver, self)._get_crash_log(
-            stdout.encode('utf8', 'replace'),
-            stderr.encode('utf8', 'replace'),
-            newer_than)
+            stdout.encode('utf8', 'replace'), stderr.encode('utf8', 'replace'), newer_than)
 
     def cmd_line(self, pixel_tests, per_test_args):
         # The returned command line is used to start _server_process. In our case, it's an interactive 'adb shell'.
         # The command line passed to the driver process is returned by _driver_cmd_line() instead.
         return self._android_commands.adb_command() + ['shell']
 
     def _android_driver_cmd_line(self, pixel_tests, per_test_args):
         return driver.Driver.cmd_line(self, pixel_tests, per_test_args)
 
     @staticmethod
     def _loop_with_timeout(condition, timeout_secs):
         deadline = time.time() + timeout_secs
         while time.time() < deadline:
             if condition():
                 return True
         return False
 
     def _all_pipes_created(self):
         return (self._android_commands.file_exists(self._in_fifo_path) and
-                self._android_commands.file_exists(self._out_fifo_path) and
-                self._android_commands.file_exists(self._err_fifo_path))
+                self._android_commands.file_exists(self._out_fifo_path) and self._android_commands.file_exists(self._err_fifo_path))
 
     def _remove_all_pipes(self):
         for file in [self._in_fifo_path, self._out_fifo_path, self._err_fifo_path]:
             self._android_commands.run(['shell', 'rm', file])
 
         return (not self._android_commands.file_exists(self._in_fifo_path) and
                 not self._android_commands.file_exists(self._out_fifo_path) and
                 not self._android_commands.file_exists(self._err_fifo_path))
 
     def start(self, pixel_tests, per_test_args, deadline):
@@ skipping 25 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):
+        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()])
+        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
 
         if not ChromiumAndroidDriver._loop_with_timeout(self._all_pipes_created, DRIVER_START_STOP_TIMEOUT_SECS):
             return False
 
         # Read back the shell prompt to ensure adb shell ready.
         deadline = time.time() + DRIVER_START_STOP_TIMEOUT_SECS
         self._server_process.start()
@@ skipping 23 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