Run auto-formatter on files in webkitpy/layout_tests/.

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/port/driver.py

 # Copyright (C) 2011 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 20 matching lines @@
 import logging
 import re
 import shlex
 import sys
 import time
 import os
 
 from webkitpy.common.system import path
 from webkitpy.common.system.profiler import ProfilerFactory
 
-
 _log = logging.getLogger(__name__)
 
-
 DRIVER_START_TIMEOUT_SECS = 30
 
 
 class DriverInput(object):
     def __init__(self, test_name, timeout, image_hash, should_run_pixel_test, args):
         self.test_name = test_name
         self.timeout = timeout  # in ms
         self.image_hash = image_hash
         self.should_run_pixel_test = should_run_pixel_test
         self.args = args
 
 
 class DriverOutput(object):
     """Groups information about a output from driver for easy passing
     and post-processing of data."""
 
-    def __init__(self, text, image, image_hash, audio, crash=False,
-            test_time=0, measurements=None, timeout=False, error='', crashed_process_name='??',
-            crashed_pid=None, crash_log=None, leak=False, leak_log=None, pid=None):
+    def __init__(self,
+                 text,
+                 image,
+                 image_hash,
+                 audio,
+                 crash=False,
+                 test_time=0,
+                 measurements=None,
+                 timeout=False,
+                 error='',
+                 crashed_process_name='??',
+                 crashed_pid=None,
+                 crash_log=None,
+                 leak=False,
+                 leak_log=None,
+                 pid=None):
         # FIXME: Args could be renamed to better clarify what they do.
         self.text = text
         self.image = image  # May be empty-string if the test crashes.
         self.image_hash = image_hash
         self.image_diff = None  # image_diff gets filled in after construction.
         self.audio = audio  # Binary format is port-dependent.
         self.crash = crash
         self.crashed_process_name = crashed_process_name
         self.crashed_pid = crashed_pid
         self.crash_log = crash_log
@@ skipping 51 matching lines @@
         # FIXME: We should probably remove _read_first_block and _read_optional_image_block and
         # instead scope these locally in run_test.
         self.error_from_test = str()
         self.err_seen_eof = False
         self._server_process = None
         self._current_cmd_line = None
 
         self._measurements = {}
         if self._port.get_option("profile"):
             profiler_name = self._port.get_option("profiler")
-            self._profiler = ProfilerFactory.create_profiler(self._port.host,
-                self._port._path_to_driver(), self._port.results_directory(), profiler_name)
+            self._profiler = ProfilerFactory.create_profiler(self._port.host, self._port._path_to_driver(),
+                                                             self._port.results_directory(), profiler_name)
         else:
             self._profiler = None
 
     def __del__(self):
         self.stop()
 
     def run_test(self, driver_input, stop_when_done):
         """Run a single test and return the results.
 
         Note that it is okay if a test times out or crashes. content_shell
@@ skipping 18 matching lines @@
         image, actual_image_hash = self._read_optional_image_block(deadline)  # The second (optional) block is image data.
 
         crashed = self.has_crashed()
         timed_out = self._server_process.timed_out
         pid = self._server_process.pid()
         leaked = self._leaked
 
         if not crashed:
             sanitizer = self._port.output_contains_sanitizer_messages(self.error_from_test)
             if sanitizer:
-                self.error_from_test = 'OUTPUT CONTAINS "' + sanitizer + '", so we are treating this test as if it crashed, even though it did not.\n\n' + self.error_from_test
+                self.error_from_test = 'OUTPUT CONTAINS "' + sanitizer + \
+                    '", so we are treating this test as if it crashed, even though it did not.\n\n' + self.error_from_test
                 crashed = True
                 self._crashed_process_name = "unknown process name"
                 self._crashed_pid = 0
 
         if stop_when_done or crashed or timed_out or leaked:
             # We call stop() even if we crashed or timed out in order to get any remaining stdout/stderr output.
             # In the timeout case, we kill the hung process as well.
             out, err = self._server_process.stop(self._port.driver_stop_timeout() if stop_when_done else 0.0)
             if out:
                 text += out
@@ skipping 10 matching lines @@
                 pid_str = str(self._crashed_pid) if self._crashed_pid else "unknown pid"
                 crash_log = 'No crash log found for %s:%s.\n' % (self._crashed_process_name, pid_str)
                 # If we were unresponsive append a message informing there may not have been a crash.
                 if self._subprocess_was_unresponsive:
                     crash_log += 'Process failed to become responsive before timing out.\n'
 
                 # Print stdout and stderr to the placeholder crash log; we want as much context as possible.
                 if self.error_from_test:
                     crash_log += '\nstdout:\n%s\nstderr:\n%s\n' % (text, self.error_from_test)
 
-        return DriverOutput(text, image, actual_image_hash, audio,
-            crash=crashed, test_time=time.time() - test_begin_time, measurements=self._measurements,
-            timeout=timed_out, error=self.error_from_test,
-            crashed_process_name=self._crashed_process_name,
-            crashed_pid=self._crashed_pid, crash_log=crash_log,
-            leak=leaked, leak_log=self._leak_log,
-            pid=pid)
+        return DriverOutput(text,
+                            image,
+                            actual_image_hash,
+                            audio,
+                            crash=crashed,
+                            test_time=time.time() - test_begin_time,
+                            measurements=self._measurements,
+                            timeout=timed_out,
+                            error=self.error_from_test,
+                            crashed_process_name=self._crashed_process_name,
+                            crashed_pid=self._crashed_pid,
+                            crash_log=crash_log,
+                            leak=leaked,
+                            leak_log=self._leak_log,
+                            pid=pid)
 
     def _get_crash_log(self, stdout, stderr, newer_than):
         return self._port._get_crash_log(self._crashed_process_name, self._crashed_pid, stdout, stderr, newer_than)
 
     # FIXME: Seems this could just be inlined into callers.
     @classmethod
     def _command_wrapper(cls, wrapper_option):
         # Hook for injecting valgrind or other runtime instrumentation,
         # used by e.g. tools/valgrind/valgrind_tests.py.
         return shlex.split(wrapper_option) if wrapper_option else []
@@ skipping 89 matching lines @@
         self.stop()
         self._driver_tempdir = self._port._filesystem.mkdtemp(prefix='%s-' % self._port.driver_name())
         server_name = self._port.driver_name()
         environment = self._port.setup_environ_for_server(server_name)
         environment = self._setup_environ_for_driver(environment)
         self._crashed_process_name = None
         self._crashed_pid = None
         self._leaked = False
         self._leak_log = None
         cmd_line = self.cmd_line(pixel_tests, per_test_args)
-        self._server_process = self._port._server_process_constructor(self._port, server_name, cmd_line, environment, logging=self._port.get_option("driver_logging"))
+        self._server_process = self._port._server_process_constructor(self._port,
+                                                                      server_name,
+                                                                      cmd_line,
+                                                                      environment,
+                                                                      logging=self._port.get_option("driver_logging"))
         self._server_process.start()
         self._current_cmd_line = cmd_line
 
         if wait_for_ready:
             deadline = time.time() + DRIVER_START_TIMEOUT_SECS
             if not self._wait_for_server_process_output(self._server_process, deadline, '#READY'):
                 _log.error("content_shell took too long to startup.")
 
     def _wait_for_server_process_output(self, server_process, deadline, text):
         output = ''
@@ skipping 42 matching lines @@
         cmd.extend(per_test_args)
         cmd.append('-')
         return cmd
 
     def _check_for_driver_crash(self, error_line):
         if error_line == "#CRASHED\n":
             # This is used on Windows to report that the process has crashed
             # See http://trac.webkit.org/changeset/65537.
             self._crashed_process_name = self._server_process.name()
             self._crashed_pid = self._server_process.pid()
-        elif (error_line.startswith("#CRASHED - ")
-            or error_line.startswith("#PROCESS UNRESPONSIVE - ")):
+        elif (error_line.startswith("#CRASHED - ") or error_line.startswith("#PROCESS UNRESPONSIVE - ")):
             # WebKitTestRunner uses this to report that the WebProcess subprocess crashed.
             match = re.match('#(?:CRASHED|PROCESS UNRESPONSIVE) - (\S+)', error_line)
             self._crashed_process_name = match.group(1) if match else 'WebProcess'
             match = re.search('pid (\d+)', error_line)
             pid = int(match.group(1)) if match else None
             self._crashed_pid = pid
             # FIXME: delete this after we're sure this code is working :)
             _log.debug('%s crash, pid = %s, error_line = %s' % (self._crashed_process_name, str(pid), error_line))
             if error_line.startswith("#PROCESS UNRESPONSIVE - "):
                 self._subprocess_was_unresponsive = True
                 self._port.sample_process(self._crashed_process_name, self._crashed_pid)
                 # We want to show this since it's not a regular crash and probably we don't have a crash log.
                 self.error_from_test += error_line
             return True
         return self.has_crashed()
 
     def _check_for_leak(self, error_line):
         if error_line.startswith("#LEAK - "):
             self._leaked = True
             match = re.match('#LEAK - (\S+) pid (\d+) (.+)\n', error_line)
             self._leak_log = match.group(3)
         return self._leaked
 
     def _command_from_driver_input(self, driver_input):
         # FIXME: performance tests pass in full URLs instead of test names.
-        if driver_input.test_name.startswith('http://') or driver_input.test_name.startswith('https://')  or driver_input.test_name == ('about:blank'):
+        if driver_input.test_name.startswith('http://') or driver_input.test_name.startswith(
+                'https://') or driver_input.test_name == ('about:blank'):
             command = driver_input.test_name
         elif self.is_http_test(driver_input.test_name) or self._should_treat_as_wpt_test(driver_input.test_name):
             command = self.test_to_uri(driver_input.test_name)
         else:
             command = self._port.abspath_for_test(driver_input.test_name)
             if sys.platform == 'cygwin':
                 command = path.cygpath(command)
 
         assert not driver_input.image_hash or driver_input.should_run_pixel_test
 
@@ skipping 27 matching lines @@
     def _read_header(self, block, line, header_text, header_attr, header_filter=None):
         if line.startswith(header_text) and getattr(block, header_attr) is None:
             value = line.split()[1]
             if header_filter:
                 value = header_filter(value)
             setattr(block, header_attr, value)
             return True
         return False
 
     def _process_stdout_line(self, block, line):
-        if (self._read_header(block, line, 'Content-Type: ', 'content_type')
-            or self._read_header(block, line, 'Content-Transfer-Encoding: ', 'encoding')
-            or self._read_header(block, line, 'Content-Length: ', '_content_length', int)
-            or self._read_header(block, line, 'ActualHash: ', 'content_hash')
-            or self._read_header(block, line, 'DumpMalloc: ', 'malloc')
-            or self._read_header(block, line, 'DumpJSHeap: ', 'js_heap')
-            or self._read_header(block, line, 'StdinPath', 'stdin_path')):
+        if (self._read_header(block, line, 'Content-Type: ', 'content_type') or
+                self._read_header(block, line, 'Content-Transfer-Encoding: ', 'encoding') or
+                self._read_header(block, line, 'Content-Length: ', '_content_length', int) or
+                self._read_header(block, line, 'ActualHash: ', 'content_hash') or
+                self._read_header(block, line, 'DumpMalloc: ', 'malloc') or
+                self._read_header(block, line, 'DumpJSHeap: ', 'js_heap') or
+                self._read_header(block, line, 'StdinPath', 'stdin_path')):
             return
         # Note, we're not reading ExpectedHash: here, but we could.
         # If the line wasn't a header, we just append it to the content.
         block.content += line
 
     def _strip_eof(self, line):
         if line and line.endswith("#EOF\n"):
             return line[:-5], True
         if line and line.endswith("#EOF\r\n"):
             _log.error("Got a CRLF-terminated #EOF - this is a driver bug.")
@@ skipping 22 matching lines @@
 
             if out_line:
                 assert not out_seen_eof
                 out_line, out_seen_eof = self._strip_eof(out_line)
             if err_line:
                 assert not self.err_seen_eof
                 err_line, self.err_seen_eof = self._strip_eof(err_line)
 
             if out_line:
                 if out_line[-1] != "\n":
-                    _log.error("Last character read from DRT stdout line was not a newline!  This indicates either a NRWT or DRT bug.")
+                    _log.error(
+                        "Last character read from DRT stdout line was not a newline!  This indicates either a NRWT or DRT bug.")
                 content_length_before_header_check = block._content_length
                 self._process_stdout_line(block, out_line)
                 # FIXME: Unlike HTTP, DRT dumps the content right after printing a Content-Length header.
                 # Don't wait until we're done with headers, just read the binary blob right now.
                 if content_length_before_header_check != block._content_length:
                     if block._content_length > 0:
                         block.content = self._server_process.read_stdout(deadline, block._content_length)
                     else:
                         _log.error("Received content of type %s with Content-Length of 0!  This indicates a bug in %s.",
                                    block.content_type, self._server_process.name())
@@ skipping 20 matching lines @@
         self.decoded_content = None
         self.malloc = None
         self.js_heap = None
         self.stdin_path = None
 
     def decode_content(self):
         if self.encoding == 'base64' and self.content is not None:
             self.decoded_content = base64.b64decode(self.content)
         else:
             self.decoded_content = self.content