Reformat webkitpy.layout_tests w/ format-webkitpy.

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

 # Copyright (C) 2010 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 54 matching lines @@
 def quote_data(data):
     txt = repr(data).replace('\\n', '\\n\n')[1:-1]
     lines = []
     for l in txt.splitlines():
         m = _trailing_spaces_re.match(l)
         if m:
             l = m.group(1) + m.group(2).replace(' ', '\x20')
         lines.append(l)
     return lines
 
+
 class ServerProcess(object):
+
     """This class provides a wrapper around a subprocess that
     implements a simple request/response usage model. The primary benefit
     is that reading responses takes a deadline, so that we don't ever block
     indefinitely. The class also handles transparently restarting processes
     as necessary to keep issuing commands."""
 
     def __init__(self, port_obj, name, cmd, env=None, universal_newlines=False, treat_no_data_as_crash=False,
                  logging=False):
         self._port = port_obj
         self._name = name  # Should be the command name (e.g. content_shell, image_diff)
@@ skipping 34 matching lines @@
         self._output = str()  # bytesarray() once we require Python 2.6
         self._error = str()  # bytesarray() once we require Python 2.6
         self._crashed = False
         self.timed_out = False
 
     def process_name(self):
         return self._name
 
     def _start(self):
         if self._proc:
-            raise ValueError("%s already running" % self._name)
+            raise ValueError('%s already running' % self._name)
         self._reset()
         # close_fds is a workaround for http://bugs.python.org/issue2320
         close_fds = not self._host.platform.is_win()
         if self._logging:
             env_str = ''
             if self._env:
-                env_str += '\n'.join("%s=%s" % (k, v) for k, v in self._env.items()) + '\n'
+                env_str += '\n'.join('%s=%s' % (k, v) for k, v in self._env.items()) + '\n'
             _log.info('CMD: \n%s%s\n', env_str, _quote_cmd(self._cmd))
         self._proc = self._host.executive.popen(self._cmd, stdin=self._host.executive.PIPE,
-            stdout=self._host.executive.PIPE,
-            stderr=self._host.executive.PIPE,
-            close_fds=close_fds,
-            env=self._env,
-            universal_newlines=self._universal_newlines)
+                                                stdout=self._host.executive.PIPE,
+                                                stderr=self._host.executive.PIPE,
+                                                close_fds=close_fds,
+                                                env=self._env,
+                                                universal_newlines=self._universal_newlines)
         self._pid = self._proc.pid
         fd = self._proc.stdout.fileno()
         if not self._use_win32_apis:
             fl = fcntl.fcntl(fd, fcntl.F_GETFL)
             fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
             fd = self._proc.stderr.fileno()
             fl = fcntl.fcntl(fd, fcntl.F_GETFL)
             fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
 
     def _handle_possible_interrupt(self):
@@ skipping 16 matching lines @@
         return None
 
     def write(self, bytes):
         """Write a request to the subprocess. The subprocess is (re-)start()'ed
         if is not already running."""
         if not self._proc:
             self._start()
         try:
             self._log_data(' IN', bytes)
             self._proc.stdin.write(bytes)
-        except IOError, e:
+        except IOError as e:
             self.stop(0.0)
             # stop() calls _reset(), so we have to set crashed to True after calling stop().
             self._crashed = True
 
     def _pop_stdout_line_if_ready(self):
         index_after_newline = self._output.find('\n') + 1
         if index_after_newline > 0:
             return self._pop_output_bytes(index_after_newline)
         return None
 
@@ skipping 16 matching lines @@
         def retrieve_bytes_from_buffers():
             stdout_line = self._pop_stdout_line_if_ready()
             if stdout_line:
                 return stdout_line, None
             stderr_line = self._pop_stderr_line_if_ready()
             if stderr_line:
                 return None, stderr_line
             return None  # Instructs the caller to keep waiting.
 
         return_value = self._read(deadline, retrieve_bytes_from_buffers)
-        # FIXME: This is a bit of a hack around the fact that _read normally only returns one value, but this caller wants it to return two.
+        # FIXME: This is a bit of a hack around the fact that _read normally only
+        # returns one value, but this caller wants it to return two.
         if return_value is None:
             return None, None
         return return_value
 
     def read_stdout(self, deadline, size):
         if size <= 0:
             raise ValueError('ServerProcess.read() called with a non-positive size: %d ' % size)
 
         def retrieve_bytes_from_stdout_buffer():
             if len(self._output) >= size:
@@ skipping 32 matching lines @@
         if self._proc.stdout.closed or self._proc.stderr.closed:
             # If the process crashed and is using FIFOs, like Chromium Android, the
             # stdout and stderr pipes will be closed.
             return
 
         out_fd = self._proc.stdout.fileno()
         err_fd = self._proc.stderr.fileno()
         select_fds = (out_fd, err_fd)
         try:
             read_fds, _, _ = select.select(select_fds, [], select_fds, max(deadline - time.time(), 0))
-        except select.error, e:
+        except select.error as e:
             # We can ignore EINVAL since it's likely the process just crashed and we'll
             # figure that out the next time through the loop in _read().
             if e.args[0] == errno.EINVAL:
                 return
             raise
 
         try:
             # Note that we may get no data during read() even though
             # select says we got something; see the select() man page
             # on linux. I don't know if this happens on Mac OS and
             # other Unixen as well, but we don't bother special-casing
             # Linux because it's relatively harmless either way.
             if out_fd in read_fds:
                 data = self._proc.stdout.read()
                 if not data and not stopping and (self._treat_no_data_as_crash or self._proc.poll()):
                     self._crashed = True
                 self._log_data('OUT', data)
                 self._output += data
 
             if err_fd in read_fds:
                 data = self._proc.stderr.read()
                 if not data and not stopping and (self._treat_no_data_as_crash or self._proc.poll()):
                     self._crashed = True
                 self._log_data('ERR', data)
                 self._error += data
-        except IOError, e:
+        except IOError as e:
             # We can ignore the IOErrors because we will detect if the subporcess crashed
             # the next time through the loop in _read()
             pass
 
     def _wait_for_data_and_update_buffers_using_win32_apis(self, deadline):
         # See http://code.activestate.com/recipes/440554-module-to-allow-asynchronous-subprocess-use-on-win/
         # and http://docs.activestate.com/activepython/2.6/pywin32/modules.html
         # for documentation on all of these win32-specific modules.
         now = time.time()
         out_fh = msvcrt.get_osfhandle(self._proc.stdout.fileno())
@@ skipping 12 matching lines @@
             time.sleep(0.01)
             now = time.time()
         return
 
     def _non_blocking_read_win32(self, handle):
         try:
             _, avail, _ = win32pipe.PeekNamedPipe(handle, 0)
             if avail > 0:
                 _, buf = win32file.ReadFile(handle, avail, None)
                 return buf
-        except Exception, e:
+        except Exception as e:
             if e[0] not in (109, errno.ESHUTDOWN):  # 109 == win32 ERROR_BROKEN_PIPE
                 raise
         return None
 
     def has_crashed(self):
         if not self._crashed and self.poll():
             self._crashed = True
             self._handle_possible_interrupt()
         return self._crashed
 
@@ skipping 64 matching lines @@
             self._proc.wait()
 
     def replace_outputs(self, stdout, stderr):
         assert self._proc
         if stdout:
             self._proc.stdout.close()
             self._proc.stdout = stdout
         if stderr:
             self._proc.stderr.close()
             self._proc.stderr = stderr