Remove all support for cygwin in run-webkit-tests.

third_party/WebKit/Tools/Scripts/webkitpy/common/system/executive.py

 # Copyright (c) 2009, Google Inc. All rights reserved.
 # Copyright (c) 2009 Apple 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
@@ skipping 10 matching lines @@
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import csv
+import ctypes
 import errno
 import logging
 import multiprocessing
 import os
 import signal
 import subprocess
 import sys
 import threading
 import time
 
-from webkitpy.common.system.filesystem import FileSystem
-
 
 _log = logging.getLogger(__name__)
 
 
 class ScriptError(Exception):
 
     def __init__(self,
                  message=None,
                  script_args=None,
                  exit_code=None,
@@ skipping 34 matching lines @@
     PIPE = subprocess.PIPE
     STDOUT = subprocess.STDOUT
     DEVNULL = open(os.devnull, 'wb')
 
     def _should_close_fds(self):
         # We need to pass close_fds=True to work around Python bug #2320
         # (otherwise we can hang when we kill DumpRenderTree when we are running
         # multiple threads). See http://bugs.python.org/issue2320 .
         # Note that close_fds isn't supported on Windows, but this bug only
         # shows up on Mac and Linux.
-        return sys.platform not in ('win32', 'cygwin')
+        return sys.platform != 'win32'
 
     def cpu_count(self):
         return multiprocessing.cpu_count()
 
     def kill_process(self, pid):
         """Attempts to kill the given pid.
+
         Will fail silently if pid does not exist or insufficient permissions.
         """
+        # According to http://docs.python.org/library/os.html
+        # os.kill isn't available on Windows.
         if sys.platform == 'win32':
-            # We only use taskkill.exe on windows (not cygwin) because subprocess.pid
-            # is a CYGWIN pid and taskkill.exe expects a windows pid.
-            # Thankfully os.kill on CYGWIN handles either pid type.
             command = ['taskkill.exe', '/f', '/t', '/pid', pid]
-            # taskkill will exit 128 if the process is not found.  We should log.
+            # taskkill will exit 128 if the process is not found. We should log.
             self.run_command(command, error_handler=self.ignore_error)
             return
 
-        # According to http://docs.python.org/library/os.html
-        # os.kill isn't available on Windows. python 2.5.5 os.kill appears
-        # to work in cygwin, however it occasionally raises EAGAIN.
-        retries_left = 10 if sys.platform == 'cygwin' else 1
-        while retries_left > 0:
-            try:
-                retries_left -= 1
-                os.kill(pid, signal.SIGKILL)
-                _ = os.waitpid(pid, os.WNOHANG)
-            except OSError as error:
-                if error.errno == errno.EAGAIN:
-                    if retries_left <= 0:
-                        _log.warning('Failed to kill pid %s.  Too many EAGAIN errors.', pid)
-                    continue
-                if error.errno == errno.ESRCH:  # The process does not exist.
-                    return
-                if error.errno == errno.EPIPE:  # The process has exited already on cygwin
-                    return
-                if error.errno == errno.ECHILD:
-                    # Can't wait on a non-child process, but the kill worked.
-                    return
-                if error.errno == errno.EACCES and sys.platform == 'cygwin':
-                    # Cygwin python sometimes can't kill native processes.
-                    return
-                raise
+        try:
+            os.kill(pid, signal.SIGKILL)
+            os.waitpid(pid, os.WNOHANG)
+        except OSError as error:
+            if error.errno == errno.ESRCH:
+                # The process does not exist.
+                return
+            if error.errno == errno.ECHILD:
+                # Can't wait on a non-child process, but the kill worked.
+                return
+            raise
 
     def _win32_check_running_pid(self, pid):
-        # importing ctypes at the top-level seems to cause weird crashes at
-        # exit under cygwin on apple's win port. Only win32 needs cygwin, so
-        # we import it here instead. See https://bugs.webkit.org/show_bug.cgi?id=91682
-        import ctypes
 
         class PROCESSENTRY32(ctypes.Structure):
             _fields_ = [('dwSize', ctypes.c_ulong),
                         ('cntUsage', ctypes.c_ulong),
                         ('th32ProcessID', ctypes.c_ulong),
                         ('th32DefaultHeapID', ctypes.POINTER(ctypes.c_ulong)),
                         ('th32ModuleID', ctypes.c_ulong),
                         ('cntThreads', ctypes.c_ulong),
                         ('th32ParentProcessID', ctypes.c_ulong),
                         ('pcPriClassBase', ctypes.c_ulong),
@@ skipping 29 matching lines @@
             return self._win32_check_running_pid(pid)
 
         try:
             os.kill(pid, 0)
             return True
         except OSError:
             return False
 
     def _running_processes(self):
         processes = []
-        if sys.platform in ('win32', 'cygwin'):
+        if sys.platform == 'win32':
             tasklist_process = self.popen(['tasklist', '/fo', 'csv'],
                                           stdout=self.PIPE, stderr=self.PIPE)
             stdout, _ = tasklist_process.communicate()
             stdout_reader = csv.reader(stdout.splitlines())
             for line in stdout_reader:
                 processes.append([column for column in line])
         else:
             ps_process = self.popen(['ps', '-eo', 'pid,comm'],
                                     stdout=self.PIPE, stderr=self.PIPE)
             stdout, _ = ps_process.communicate()
@@ skipping 15 matching lines @@
                 pid = line[1]
                 if process_name_filter(process_name):
                     running_pids.append(int(pid))
             except (ValueError, IndexError):
                 pass
 
         return sorted(running_pids)
 
     def process_dump(self):
         ps_process = None
-        if sys.platform in ('win32', 'cygwin'):
+        if sys.platform in 'win32':
             ps_process = self.popen(
                 ['wmic', 'process', 'get',
                  'ProcessId,ParentProcessId,CommandLine'],
                 stdout=self.PIPE, stderr=self.PIPE)
         else:
             ps_process = self.popen(['ps', 'aux'], stdout=self.PIPE, stderr=self.PIPE)
 
         stdout, _ = ps_process.communicate()
         return [line.strip() for line in stdout.splitlines()]
 
@@ skipping 134 matching lines @@
         # current code page.
         if sys.platform == 'win32' and sys.version < '3':
             return 'mbcs'
         # All other platforms use UTF-8.
         # FIXME: Using UTF-8 on Cygwin will confuse Windows-native commands
         # which will expect arguments to be encoded using the current code
         # page.
         return 'utf-8'
 
     def _should_encode_child_process_arguments(self):
-        # Cygwin's Python's os.execv doesn't support unicode command
-        # arguments, and neither does Cygwin's execv itself.
-        if sys.platform == 'cygwin':
-            return True
-
         # Win32 Python 2.x uses CreateProcessA rather than CreateProcessW
         # to launch subprocesses, so we have to encode arguments using the
         # current code page.
         if sys.platform == 'win32' and sys.version < '3':
             return True
 
         return False
 
     def _encode_argument_if_needed(self, argument):
         if not self._should_encode_child_process_arguments():
@@ skipping 13 matching lines @@
 
     def call(self, args, **kwargs):
         return subprocess.call(self._stringify_args(args), **kwargs)
 
     def run_in_parallel(self, command_lines_and_cwds, processes=None):
         """Runs a list of (cmd_line list, cwd string) tuples in parallel and returns a list of (retcode, stdout, stderr) tuples."""
         assert len(command_lines_and_cwds)
         return self.map(_run_command_thunk, command_lines_and_cwds, processes)
 
     def map(self, thunk, arglist, processes=None):
-        if sys.platform in ('cygwin', 'win32') or len(arglist) == 1:
+        if sys.platform == 'win32' or len(arglist) == 1:
             return map(thunk, arglist)
         pool = multiprocessing.Pool(processes=(processes or multiprocessing.cpu_count()))
         try:
             return pool.map(thunk, arglist)
         finally:
             pool.close()
             pool.join()
 
 
 def _run_command_thunk(cmd_line_and_cwd):
     # Note that this needs to be a bare module (and hence Picklable) method to work with multiprocessing.Pool.
     (cmd_line, cwd) = cmd_line_and_cwd
     proc = subprocess.Popen(cmd_line, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     stdout, stderr = proc.communicate()
     return (proc.returncode, stdout, stderr)