Reformat webkitpy.layout_tests w/ format-webkitpy.

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 44 matching lines @@
 # This path is defined in Chromium's base/test/test_support_android.cc.
 DEVICE_SOURCE_ROOT_DIR = '/data/local/tmp/'
 
 # The layout tests directory on device, which has two usages:
 # 1. as a virtual path in file urls that will be bridged to HTTP.
 # 2. pointing to some files that are pushed to the device for tests that
 # don't work on file-over-http (e.g. blob protocol tests).
 DEVICE_WEBKIT_BASE_DIR = DEVICE_SOURCE_ROOT_DIR + 'third_party/WebKit/'
 DEVICE_LAYOUT_TESTS_DIR = DEVICE_WEBKIT_BASE_DIR + 'LayoutTests/'
 
-SCALING_GOVERNORS_PATTERN = "/sys/devices/system/cpu/cpu*/cpufreq/scaling_governor"
-KPTR_RESTRICT_PATH = "/proc/sys/kernel/kptr_restrict"
+SCALING_GOVERNORS_PATTERN = '/sys/devices/system/cpu/cpu*/cpufreq/scaling_governor'
+KPTR_RESTRICT_PATH = '/proc/sys/kernel/kptr_restrict'
 
 # All the test cases are still served to the test runner through file protocol,
 # but we use a file-to-http feature to bridge the file request to host's http
 # server to get the real test files and corresponding resources.
 # See webkit/support/platform_support_android.cc for the other side of this bridge.
 PERF_TEST_PATH_PREFIX = '/all-perf-tests'
 LAYOUT_TEST_PATH_PREFIX = '/all-tests'
 
 # All ports the Android forwarder to forward.
 # 8000, 8080 and 8443 are for http/https tests.
@@ skipping 37 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',
     # User style URLs are accessed as local files in webkit_support.
     'http/tests/security/resources/cssStyle.css',
     # Media tests need to access audio/video as files.
     'media/content',
     'compositing/resources/video.mp4',
 ]
 
 MD5SUM_DEVICE_FILE_NAME = 'md5sum_bin'
 MD5SUM_HOST_FILE_NAME = 'md5sum_bin_host'
 MD5SUM_DEVICE_PATH = '/data/local/tmp/' + MD5SUM_DEVICE_FILE_NAME
 
 
 # Information required when running layout tests using content_shell as the test runner.
 class ContentShellDriverDetails():
+
     def device_cache_directory(self):
         return self.device_directory() + 'cache/'
 
     def device_fonts_directory(self):
         return self.device_directory() + 'fonts/'
 
     def device_forwarder_path(self):
         return self.device_directory() + 'forwarder'
 
     def device_fifo_directory(self):
@@ skipping 88 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]
 
     @staticmethod
     def set_adb_command_path_options(paths):
         AndroidCommands._adb_command_path_options = paths
 
     @staticmethod
     def adb_command_path(executive, debug_logging):
         if AndroidCommands._adb_command_path:
             return AndroidCommands._adb_command_path
 
         assert AndroidCommands._adb_command_path_options, 'No commands paths have been set to look for the "adb" command.'
 
         command_path = None
         command_version = None
         for path_option in AndroidCommands._adb_command_path_options:
             path_version = AndroidCommands._determine_adb_version(path_option, executive, debug_logging)
             if not path_version:
                 continue
-            if command_version != None and path_version < command_version:
+            if command_version is not None and path_version < command_version:
                 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
 
@@ skipping 57 matching lines @@
         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))
+                             % (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 59 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')])
+                                                      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 14 matching lines @@
         # 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 check_wdiff(self, logging=True):
         return self._host_port.check_wdiff(logging)
 
     def check_build(self, needs_http, printer):
         exit_status = super(AndroidPort, self).check_build(needs_http, printer)
         if exit_status:
             return exit_status
 
         result = self._check_file_exists(self.path_to_md5sum(), 'md5sum utility')
         result = self._check_file_exists(self.path_to_md5sum_host(), 'md5sum host utility') and result
         result = self._check_file_exists(self.path_to_forwarder(), 'forwarder utility') and result
 
         if not result:
             # There is a race condition in adb at least <= 4.3 on Linux that causes it to go offline periodically
             # We set the processor affinity for any running adb process to attempt to work around this.
             # See crbug.com/268450
             if self.host.platform.is_linux():
                 pids = self._executive.running_pids(lambda name: 'adb' in name)
                 if not pids:
                     # Apparently adb is not running, which is unusual. Running any adb command should start it.
                     self._executive.run_command(['adb', 'devices'])
                     pids = self._executive.running_pids(lambda name: 'adb' in name)
                 if not pids:
-                    _log.error("The adb daemon does not appear to be running.")
+                    _log.error('The adb daemon does not appear to be running.')
                     return False
 
                 for pid in pids:
                     self._executive.run_command(['taskset', '-p', '-c', '0', str(pid)])
 
         if not result:
             _log.error('For complete Android build requirements, please see:')
             _log.error('')
             _log.error('    http://code.google.com/p/chromium/wiki/AndroidBuildInstructions')
             return test_run_results.UNEXPECTED_ERROR_EXIT_STATUS
@@ skipping 12 matching lines @@
             d = self.create_driver(worker_number)
             serial = d._android_commands.get_serial()
 
             def log_safely(msg, throttled=True):
                 if throttled:
                     callback = printer.write_throttled_update
                 else:
                     callback = printer.write_update
                 lock.acquire()
                 try:
-                    callback("[%s] %s" % (serial, msg))
+                    callback('[%s] %s' % (serial, msg))
                 finally:
                     lock.release()
 
-            log_safely("preparing device", throttled=False)
+            log_safely('preparing device', throttled=False)
             try:
                 d._setup_test(log_safely)
-                log_safely("device prepared", throttled=False)
+                log_safely('device prepared', throttled=False)
             except (ScriptError, driver.DeviceFailure) as e:
                 lock.acquire()
-                _log.warning("[%s] failed to prepare_device: %s" % (serial, str(e)))
+                _log.warning('[%s] failed to prepare_device: %s' % (serial, str(e)))
                 lock.release()
             except KeyboardInterrupt:
                 if pool:
                     pool.terminate()
 
         # FIXME: It would be nice if we knew how many workers we needed.
         num_workers = self.default_child_processes()
         num_child_processes = int(self.get_option('child_processes'))
         if num_child_processes:
             num_workers = min(num_workers, num_child_processes)
@@ skipping 28 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()
@@ skipping 53 matching lines @@
     def _android_server_process_constructor(port, server_name, cmd_line, env=None, logging=False):
         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)
+        super(AndroidPerf, self).__init__(host, executable_path, output_dir, 'data', identifier)
         self._android_commands = android_commands
         self._perf_process = None
         self._symfs_path = symfs_path
         self._kallsyms_path = kallsyms_path
 
     def check_configuration(self):
         # Check that perf is installed
         if not self._android_commands.file_exists('/system/bin/perf'):
-            print "Cannot find /system/bin/perf on device %s" % self._android_commands.get_serial()
+            print 'Cannot find /system/bin/perf on device %s' % self._android_commands.get_serial()
             return False
 
         # Check that the device is a userdebug build (or at least has the necessary libraries).
         if self._android_commands.run(['shell', 'getprop', 'ro.build.type']).strip() != 'userdebug':
-            print "Device %s is not flashed with a userdebug build of Android" % self._android_commands.get_serial()
+            print 'Device %s is not flashed with a userdebug build of Android' % self._android_commands.get_serial()
             return False
 
         # FIXME: Check that the binary actually is perf-able (has stackframe pointers)?
         # objdump -s a function and make sure it modifies the fp?
         # Instruct users to rebuild after export GYP_DEFINES="profiling=1 $GYP_DEFINES"
         return True
 
     def print_setup_instructions(self):
         print """
 perf on android requires a 'userdebug' build of Android, see:
 http://source.android.com/source/building-devices.html"
 
 The perf command can be built from:
 https://android.googlesource.com/platform/external/linux-tools-perf/
 and requires libefl, libebl, libdw, and libdwfl available in:
 https://android.googlesource.com/platform/external/elfutils/
 
 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(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
 
     def _find_perfhost_binary(self):
         perfhost_version = self._perf_version_string('perfhost_linux')
         if perfhost_version:
             return 'perfhost_linux'
         perf_version = self._perf_version_string('perf')
         if perf_version:
             return 'perf'
         return None
 
     def _perfhost_path(self):
         if self._have_searched_for_perf_host:
             return self._cached_perf_host_path
         self._have_searched_for_perf_host = True
         self._cached_perf_host_path = self._find_perfhost_binary()
         return self._cached_perf_host_path
 
     def _first_ten_lines_of_profile(self, perf_output):
-        match = re.search("^#[^\n]*\n((?: [^\n]*\n){1,10})", perf_output, re.MULTILINE)
+        match = re.search('^#[^\n]*\n((?: [^\n]*\n){1,10})', perf_output, re.MULTILINE)
         return match.group(1) if match else None
 
     def profile_after_exit(self):
         perf_exitcode = self._perf_process.wait()
         if perf_exitcode != 0:
             print "Perf failed (exit code: %i), can't process results." % perf_exitcode
             return
 
         self._android_commands.pull('/data/perf.data', self._output_path)
 
@@ skipping 18 matching lines @@
 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'
-        print "To view the full profile, run:"
+        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, 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"):
+        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):
         self._teardown_performance()
         self._clean_up_cmd_line()
         super(ChromiumAndroidDriver, self).__del__()
 
     def _update_kallsyms_cache(self, output_dir):
-        kallsyms_name = "%s-kallsyms" % self._android_commands.get_serial()
+        kallsyms_name = '%s-kallsyms' % self._android_commands.get_serial()
         kallsyms_cache_path = self._port.host.filesystem.join(output_dir, kallsyms_name)
 
         self._android_commands.restart_as_root()
 
         saved_kptr_restrict = self._android_commands.run(['shell', 'cat', KPTR_RESTRICT_PATH]).strip()
         self._android_commands.run(['shell', 'echo', '0', '>', KPTR_RESTRICT_PATH])
 
-        print "Updating kallsyms file (%s) from device" % kallsyms_cache_path
-        self._android_commands.pull("/proc/kallsyms", kallsyms_cache_path)
+        print 'Updating kallsyms file (%s) from device' % kallsyms_cache_path
+        self._android_commands.pull('/proc/kallsyms', kallsyms_cache_path)
 
         self._android_commands.run(['shell', 'echo', saved_kptr_restrict, '>', KPTR_RESTRICT_PATH])
 
         return kallsyms_cache_path
 
     def _find_or_create_symfs(self):
         environment = self._port.host.copy_current_environment()
         env = environment.to_dictionary()
         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')
-            print "ANDROID_SYMFS not set, using %s" % symfs_path
+            print '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))
 
-        # FIXME: Ideally we'd check the sha1's first and make a soft-link instead of copying (since we probably never care about windows).
-        print "Updating symfs libary (%s) from built copy (%s)" % (symfs_library_path, 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).
+        print 'Updating symfs libary (%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()
         if not self._android_commands.file_exists(MD5SUM_DEVICE_PATH):
             if not self._android_commands.push(self._md5sum_path, MD5SUM_DEVICE_PATH):
                 self._abort('Could not push md5sum to device')
@@ skipping 45 matching lines @@
         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)
+            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)
+            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)
+        log_callback('checking %s' % basename)
         if not self._files_match(host_file, device_file):
-            log_callback("pushing %s" % basename)
+            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")
+        log_callback('checking 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")
+        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")
+        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))
 
         return super(ChromiumAndroidDriver, self)._get_crash_log(stdout, stderr, 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)
@@ skipping 29 matching lines @@
         if self._current_cmd_line is None:
             self._current_android_cmd_line = None
         if new_cmd_line != self._current_android_cmd_line:
             self.stop()
         self._current_android_cmd_line = new_cmd_line
 
         super(ChromiumAndroidDriver, self).start(pixel_tests, per_test_args, deadline)
 
     def _start(self, pixel_tests, per_test_args):
         if not self._android_devices.is_device_prepared(self._android_commands.get_serial()):
-            raise driver.DeviceFailure("%s is not prepared in _start()" % self._android_commands.get_serial())
+            raise driver.DeviceFailure('%s is not prepared in _start()' % self._android_commands.get_serial())
 
         for retries in range(3):
             try:
                 if self._start_once(pixel_tests, per_test_args):
                     return
             except ScriptError as e:
                 self._abort('ScriptError("%s") in _start()' % str(e))
 
             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 -D %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 33 matching lines @@
         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")
+        self._log_debug('content_shell is ready')
         return True
 
     def _pid_from_android_ps_output(self, ps_output, package_name):
         # ps output seems to be fixed width, we only care about the name and the pid
         # u0_a72    21630 125   947920 59364 ffffffff 400beee4 S org.chromium.native_test
         for line in ps_output.split('\n'):
             if line.find(self._driver_details.package_name()) != -1:
                 match = re.match(r'\S+\s+(\d+)', line)
                 return int(match.group(1))
 
@@ skipping 70 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