Remove cruft from having to do bookeeping of options.stdout.

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 531 matching lines @@
   return config_dir, env['entries']
 
 
 class WorkItem(object):
   """One work item."""
   # A list of string, each being a WorkItem name.
   requirements = []
   # A unique string representing this work item.
   name = None
 
-  def run(self, work_queue, options):
-    """work_queue and options are passed as keyword arguments so they should be
+  def run(self, work_queue):
+    """work_queue is passed as keyword argument so it should be
     the last parameters of the function when you override it."""
     pass
 
 
 class ExecutionQueue(object):
   """Runs a set of WorkItem that have interdependencies and were WorkItem are
   added as they are processed.
 
   In gclient's case, Dependencies sometime needs to be run out of order due to
   From() keyword. This class manages that all the required dependencies are run
@@ skipping 90 matching lines @@
 
   def _flush_terminated_threads(self):
     """Flush threads that have terminated."""
     running = self.running
     self.running = []
     for t in running:
       if t.isAlive():
         self.running.append(t)
       else:
         t.join()
-        t.kwargs['options'].stdout.full_flush()
+        sys.stdout.full_flush()
         if self.progress:
           self.progress.update(1)
         assert not t.item.name in self.ran
         if not t.item.name in self.ran:
           self.ran.append(t.item.name)
 
   def _run_one_task(self, task_item, args, kwargs):
     if self.jobs > 1:
       # Start the thread.
       index = len(self.ran) + len(self.running) + 1
-      # Copy 'options'.
-      task_kwargs = kwargs.copy()
-      task_kwargs['options'] = copy.copy(task_kwargs['options'])
-      new_thread = self._Worker(task_item, index, args, task_kwargs)
+      new_thread = self._Worker(task_item, index, args, kwargs)
       self.running.append(new_thread)
       new_thread.start()
     else:
       # Run the 'thread' inside the main thread. Don't try to catch any
       # exception.
       task_item.run(*args, **kwargs)
       self.ran.append(task_item.name)
       if self.progress:
         self.progress.update(1)
 
@@ skipping 18 matching lines @@
         logging.info('Caught exception in thread %s' % self.item.name)
         logging.info(str(sys.exc_info()))
         work_queue.exceptions.put(sys.exc_info())
       logging.info('Task %s done' % self.item.name)
 
       work_queue.ready_cond.acquire()
       try:
         work_queue.ready_cond.notifyAll()
       finally:
         work_queue.ready_cond.release()