Fix Checkout.post_processsors setup. __init__() was ignoring the argument!

checkout.py

 # coding=utf8
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 from __future__ import with_statement
@@ skipping 47 matching lines @@
 class CheckoutBase(object):
   # Set to None to have verbose output.
   VOID = subprocess2.VOID
 
   def __init__(self, root_dir, project_name, post_processors):
     """
     Args:
       post_processor: list of lambda(checkout, patches) to call on each of the
                       modified files.
     """
+    super(CheckoutBase, self).__init__()
     self.root_dir = root_dir
     self.project_name = project_name
     if self.project_name is None:
       self.project_path = self.root_dir
     else:
       self.project_path = os.path.join(self.root_dir, self.project_name)
     # Only used for logging purposes.
     self._last_seen_revision = None
-    self.post_processors = None
+    self.post_processors = post_processors
     assert self.root_dir
     assert self.project_path
 
   def get_settings(self, key):
     return get_code_review_setting(self.project_path, key)
 
   def prepare(self, revision):
     """Checks out a clean copy of the tree and removes any local modification.
 
     This function shouldn't throw unless the remote repository is inaccessible,
@@ skipping 65 matching lines @@
             p.filename, '%s%s' % (stdout, getattr(e, 'stdout', None)))
 
   def commit(self, commit_message, user):
     """Stubbed out."""
     raise NotImplementedError('RawCheckout can\'t commit')
 
 
 class SvnConfig(object):
   """Parses a svn configuration file."""
   def __init__(self, svn_config_dir=None):
+    super(SvnConfig, self).__init__()
     self.svn_config_dir = svn_config_dir
     self.default = not bool(self.svn_config_dir)
     if not self.svn_config_dir:
       if sys.platform == 'win32':
         self.svn_config_dir = os.path.join(os.environ['APPDATA'], 'Subversion')
       else:
         self.svn_config_dir = os.path.join(os.environ['HOME'], '.subversion')
     svn_config_file = os.path.join(self.svn_config_dir, 'config')
     parser = ConfigParser.SafeConfigParser()
     if os.path.isfile(svn_config_file):
@@ skipping 62 matching lines @@
       v = v.strip()
       assert not k in values
       values[k] = v
     return values.get(key, None)
 
 
 class SvnCheckout(CheckoutBase, SvnMixIn):
   """Manages a subversion checkout."""
   def __init__(self, root_dir, project_name, commit_user, commit_pwd, svn_url,
       post_processors=None):
-    super(SvnCheckout, self).__init__(root_dir, project_name, post_processors)
+    CheckoutBase.__init__(self, root_dir, project_name, post_processors)
+    SvnMixIn.__init__(self)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_url = svn_url
     assert bool(self.commit_user) >= bool(self.commit_pwd)
 
   def prepare(self, revision):
     # Will checkout if the directory is not present.
     assert self.svn_url
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
@@ skipping 252 matching lines @@
     return branches, active
 
 
 class GitSvnCheckoutBase(GitCheckoutBase, SvnMixIn):
   """Base class for git-svn checkout. Not to be used as-is."""
   def __init__(self,
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
       svn_url, trunk, post_processors=None):
     """trunk is optional."""
-    super(GitSvnCheckoutBase, self).__init__(
-        root_dir, project_name + '.git', remote_branch, post_processors)
+    GitCheckoutBase.__init__(
+        self, root_dir, project_name + '.git', remote_branch, post_processors)
+    SvnMixIn.__init__(self)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     # svn_url in this case is the root of the svn repository.
     self.svn_url = svn_url
     self.trunk = trunk
     assert bool(self.commit_user) >= bool(self.commit_pwd)
     assert self.svn_url
     assert self.trunk
     self._cache_svn_auth()
 
@@ skipping 150 matching lines @@
            self.svn_url, self.project_path,
            '--quiet'],
           cwd=self.root_dir,
           stderr=subprocess2.STDOUT)
     return super(GitSvnCheckout, self).prepare(revision)
 
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout):
+    super(ReadOnlyCheckout, self).__init__()
     self.checkout = checkout
 
   def prepare(self, revision):
     return self.checkout.prepare(revision)
 
   def get_settings(self, key):
     return self.checkout.get_settings(key)
 
   def apply_patch(self, patches):
     return self.checkout.apply_patch(patches)
 
   def commit(self, message, user):  # pylint: disable=R0201
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path