Remove kwargs copy, it is not necessary. Remove ordered argument support from popen to simplify it.

gclient_utils.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # 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
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 20 matching lines @@
   """CheckCall() returned non-0."""
   def __init__(self, command, cwd, retcode, stdout, stderr=None):
     OSError.__init__(self, command, cwd, retcode, stdout, stderr)
     self.command = command
     self.cwd = cwd
     self.retcode = retcode
     self.stdout = stdout
     self.stderr = stderr
 
 
-def Popen(*args, **kwargs):
+def Popen(args, **kwargs):
   """Calls subprocess.Popen() with hacks to work around certain behaviors.
 
   Ensure English outpout for svn and make it work reliably on Windows.
   """
-  copied = False
+  logging.debug(u'%s, cwd=%s' % (u' '.join(args), kwargs.get('cwd', '')))
   if not 'env' in kwargs:
-    copied = True
-    kwargs = kwargs.copy()
     # It's easier to parse the stdout if it is always in English.
     kwargs['env'] = os.environ.copy()
     kwargs['env']['LANGUAGE'] = 'en'
   if not 'shell' in kwargs:
-    if not copied:
-      kwargs = kwargs.copy()
     # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for the
     # executable, but shell=True makes subprocess on Linux fail when it's called
     # with a list because it only tries to execute the first item in the list.
     kwargs['shell'] = (sys.platform=='win32')
-  return subprocess.Popen(*args, **kwargs)
+  return subprocess.Popen(args, **kwargs)
 
 
 def CheckCall(command, cwd=None, print_error=True):
   """Similar subprocess.check_call() but redirects stdout and
   returns (stdout, stderr).
 
   Works on python 2.4
   """
-  logging.debug('%s, cwd=%s' % (str(command), str(cwd)))
   try:
     stderr = None
     if not print_error:
       stderr = subprocess.PIPE
     process = Popen(command, cwd=cwd, stdout=subprocess.PIPE, stderr=stderr)
     std_out, std_err = process.communicate()
   except OSError, e:
     raise CheckCallError(command, cwd, e.errno, None)
   if process.returncode:
     raise CheckCallError(command, cwd, process.returncode, std_out, std_err)
@@ skipping 209 matching lines @@
                of the subprocess's output. Each line has the trailing newline
                character trimmed.
     stdout: Can be any bufferable output.
 
   stderr is always redirected to stdout.
   """
   assert print_stdout or filter_fn
   stdout = stdout or sys.stdout
   filter_fn = filter_fn or (lambda x: None)
   assert not 'stderr' in kwargs
-  logging.debug(args)
   kid = Popen(args, bufsize=0,
               stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
               **kwargs)
 
   # Do a flush of stdout before we begin reading from the subprocess's stdout
   last_flushed_at = time.time()
   stdout.flush()
 
   # Also, we need to forward stdout to prevent weird re-ordering of output.
   # This has to be done on a per byte basis to make sure it is not buffered:
@@ skipping 221 matching lines @@
         if exception:
           self.parent.exceptions.append(exception)
         if self.parent.progress:
           self.parent.progress.update(1)
         assert not self.item.name in self.parent.ran
         if not self.item.name in self.parent.ran:
           self.parent.ran.append(self.item.name)
       finally:
         self.parent.ready_cond.notifyAll()
         self.parent.ready_cond.release()