Revert of Fix pylint warnings in webkitpy/common/.

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 19 matching lines @@
 import csv
 import errno
 import logging
 import multiprocessing
 import os
 import signal
 import subprocess
 import sys
 import time
 
+from webkitpy.common.system.outputtee import Tee
 from webkitpy.common.system.filesystem import FileSystem
 
 
 _log = logging.getLogger(__name__)
 
 
 class ScriptError(Exception):
 
     def __init__(self,
                  message=None,
@@ skipping 110 matching lines @@
                     # Cygwin python sometimes can't kill native processes.
                     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
 
-        # pylint: disable=invalid-name
         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),
                         ("dwFlags", ctypes.c_ulong),
                         ("szExeFile", ctypes.c_char * 260)]
 
         CreateToolhelp32Snapshot = ctypes.windll.kernel32.CreateToolhelp32Snapshot
         Process32First = ctypes.windll.kernel32.Process32First
         Process32Next = ctypes.windll.kernel32.Process32Next
         CloseHandle = ctypes.windll.kernel32.CloseHandle
         TH32CS_SNAPPROCESS = 0x00000002  # win32 magic number
         hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
         pe32 = PROCESSENTRY32()
-        pe32.dwSize = ctypes.sizeof(PROCESSENTRY32)  # pylint: disable=attribute-defined-outside-init
+        pe32.dwSize = ctypes.sizeof(PROCESSENTRY32)
         result = False
         if not Process32First(hProcessSnap, ctypes.byref(pe32)):
             _log.debug("Failed getting first process.")
             CloseHandle(hProcessSnap)
             return result
         while True:
             if pe32.th32ProcessID == pid:
                 result = True
                 break
             if not Process32Next(hProcessSnap, ctypes.byref(pe32)):
@@ skipping 103 matching lines @@
     # updated to use an Executive object.
 
     @staticmethod
     def default_error_handler(error):
         raise error
 
     @staticmethod
     def ignore_error(error):
         pass
 
-    def _compute_stdin(self, input_obj):
+    def _compute_stdin(self, input):
         """Returns (stdin, string_to_communicate)"""
         # FIXME: We should be returning /dev/null for stdin
         # or closing stdin after process creation to prevent
         # child processes from getting input from the user.
-        if not input_obj:
+        if not input:
             return (None, None)
-        if hasattr(input_obj, "read"):  # Check if the input_obj is a file.
-            return (input_obj, None)  # Assume the file is in the right encoding.
+        if hasattr(input, "read"):  # Check if the input is a file.
+            return (input, None)  # Assume the file is in the right encoding.
 
         # Popen in Python 2.5 and before does not automatically encode unicode objects.
         # http://bugs.python.org/issue5290
         # See https://bugs.webkit.org/show_bug.cgi?id=37528
         # for an example of a regression caused by passing a unicode string directly.
         # FIXME: We may need to encode differently on different platforms.
-        if isinstance(input_obj, unicode):
-            input_obj = input_obj.encode(self._child_process_encoding())
-        return (self.PIPE, input_obj)
+        if isinstance(input, unicode):
+            input = input.encode(self._child_process_encoding())
+        return (self.PIPE, input)
 
     def command_for_printing(self, args):
         """Returns a print-ready string representing command args.
         The string should be copy/paste ready for execution in a shell."""
         args = self._stringify_args(args)
         escaped_args = []
         for arg in args:
             if isinstance(arg, unicode):
                 # Escape any non-ascii characters for easy copy/paste
                 arg = arg.encode("unicode_escape")
             # FIXME: Do we need to fix quotes here?
             escaped_args.append(arg)
         return " ".join(escaped_args)
 
     def run_command(self,
                     args,
                     cwd=None,
                     env=None,
-                    input_func=None,
+                    input=None,
                     error_handler=None,
                     return_exit_code=False,
                     return_stderr=True,
                     decode_output=True, debug_logging=True):
         """Popen wrapper for convenience and to work around python bugs."""
         assert isinstance(args, list) or isinstance(args, tuple)
         start_time = time.time()
 
-        stdin, string_to_communicate = self._compute_stdin(input_func)
+        stdin, string_to_communicate = self._compute_stdin(input)
         stderr = self.STDOUT if return_stderr else None
 
         process = self.popen(args,
                              stdin=stdin,
                              stdout=self.PIPE,
                              stderr=stderr,
                              cwd=cwd,
                              env=env,
                              close_fds=self._should_close_fds())
         output = process.communicate(string_to_communicate)[0]
@@ skipping 87 matching lines @@
             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)