Remove unused print_output argument from upload.py

third_party/upload.py

 #!/usr/bin/env python
 # coding: utf-8
 #
 # Copyright 2007 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 824 matching lines @@
 
 
 def GetContentType(filename):
   """Helper to guess the content-type from the filename."""
   return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
 
 
 # Use a shell for subcommands on Windows to get a PATH search.
 use_shell = sys.platform.startswith("win")
 
-def RunShellWithReturnCodeAndStderr(command, print_output=False,
-                           universal_newlines=True,
-                           env=os.environ):
+def RunShellWithReturnCodeAndStderr(command, universal_newlines=True,
+                                    env=os.environ):
   """Run a command and return output from stdout, stderr and the return code.
 
   Args:
     command: Command to execute.
-    print_output: If True, the output is printed to stdout.
-                  If False, both stdout and stderr are ignored.
     universal_newlines: Use universal_newlines flag (default: True).
 
   Returns:
     Tuple (stdout, stderr, return code)
   """
   LOGGER.info("Running %s", command)
   env = env.copy()
   env['LC_MESSAGES'] = 'C'
   p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                        shell=use_shell, universal_newlines=universal_newlines,
                        env=env)
-  if print_output:
-    # It's very hard to stream both stdout and stderr at the same time
-    # without the potential for deadlocks. We will hope for the best
-    # since this code path is rarely used.
-    output_array = []
-    while True:
-      line = p.stdout.readline()
-      if not line:
-        break
-      print line.strip("\n")
-      output_array.append(line)
-    output = "".join(output_array)
-    p.wait()
-    errout = p.stderr.read()
-    if errout:
-      print >> sys.stderr, errout
-  else:
-    output, errout = p.communicate()
+  output, errout = p.communicate()
   p.stdout.close()
   p.stderr.close()
   return output, errout, p.returncode
 
-def RunShellWithReturnCode(command, print_output=False,
-                           universal_newlines=True,
-                           env=os.environ):
+def RunShellWithReturnCode(command, universal_newlines=True, env=os.environ):
   """Run a command and return output from stdout and the return code."""
-  out, err, retcode = RunShellWithReturnCodeAndStderr(command, print_output,
+  out, err, retcode = RunShellWithReturnCodeAndStderr(command,
                            universal_newlines, env)
   return out, retcode
 
 def RunShell(command, silent_ok=False, universal_newlines=True,
-             print_output=False, env=os.environ):
-  data, retcode = RunShellWithReturnCode(command, print_output,
-                                         universal_newlines, env)
+             env=os.environ):
+  data, retcode = RunShellWithReturnCode(command, universal_newlines, env)
   if retcode:
     ErrorExit("Got error status from %s:\n%s" % (command, data))
   if not silent_ok and not data:
     ErrorExit("No output from %s" % command)
   return data
 
 
 class VersionControlSystem(object):
   """Abstract base class providing an interface to the VCS."""
 
@@ skipping 852 matching lines @@
       args.extend(["-G"])
     if self.p4_port:
       args.extend(["-p", self.p4_port])
     if self.p4_client:
       args.extend(["-c", self.p4_client])
     if self.p4_user:
       args.extend(["-u", self.p4_user])
     args.extend(extra_args)
 
     data, retcode = RunShellWithReturnCode(
-        args, print_output=False, universal_newlines=universal_newlines)
+        args, universal_newlines=universal_newlines)
     if marshal_output and data:
       data = marshal.loads(data)
     return data, retcode
 
   def RunPerforceCommand(self, extra_args, marshal_output=False,
                          universal_newlines=True):
     # This might be a good place to cache call results, since things like
     # describe or fstat might get called repeatedly.
     data, retcode = self.RunPerforceCommandWithReturnCode(
         extra_args, marshal_output, universal_newlines)
@@ skipping 773 matching lines @@
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
   except auth.AuthenticationError as e:
     print >> sys.stderr, e
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()