Remove deprecated and unused run_and_throw_if_fail from webkitpy

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 97 matching lines @@
         while True:
             output_line = child_process.stdout.readline()
             if output_line == "" and child_process.poll() != None:
                 # poll() is not threadsafe and can throw OSError due to:
                 # http://bugs.python.org/issue1731717
                 return child_process.poll()
             # We assume that the child process wrote to us in utf-8,
             # so no re-encoding is necessary before writing here.
             teed_output.write(output_line)
 
-    # FIXME: Remove this deprecated method and move callers to run_command.
-    # FIXME: This method is a hack to allow running command which both
-    # capture their output and print out to stdin.  Useful for things
-    # like "build-webkit" where we want to display to the user that we're building
-    # but still have the output to stuff into a log file.
-    def run_and_throw_if_fail(self, args, quiet=False, decode_output=True, **kwargs):
-        # Cache the child's output locally so it can be used for error reports.
-        child_out_file = StringIO.StringIO()
-        tee_stdout = sys.stdout
-        if quiet:
-            dev_null = open(os.devnull, "w")  # FIXME: Does this need an encoding?
-            tee_stdout = dev_null
-        child_stdout = Tee(child_out_file, tee_stdout)
-        exit_code = self._run_command_with_teed_output(args, child_stdout, **kwargs)
-        if quiet:
-            dev_null.close()
-
-        child_output = child_out_file.getvalue()
-        child_out_file.close()
-
-        if decode_output:
-            child_output = child_output.decode(self._child_process_encoding())
-
-        if exit_code:
-            raise ScriptError(script_args=args,
-                              exit_code=exit_code,
-                              output=child_output)
-        return child_output
-
     def cpu_count(self):
         return multiprocessing.cpu_count()
 
     @staticmethod
     def interpreter_for_script(script_path, fs=None):
         fs = fs or FileSystem()
         lines = fs.read_text_file(script_path).splitlines()
         if not len(lines):
             return None
         first_line = lines[0]
@@ skipping 204 matching lines @@
         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)
 
-    # FIXME: run_and_throw_if_fail should be merged into this method.
     def run_command(self,
                     args,
                     cwd=None,
                     env=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."""
@@ skipping 101 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)