Have apply_patch.py/checkout.py stage git patches instead of committing them

checkout.py

 # coding=utf8
 # Copyright (c) 2012 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.
 """
 
 import ConfigParser
@@ skipping 113 matching lines @@
     """Checks out a clean copy of the tree and removes any local modification.
 
     This function shouldn't throw unless the remote repository is inaccessible,
     there is no free disk space or hard issues like that.
 
     Args:
       revision: The revision it should sync to, SCM specific.
     """
     raise NotImplementedError()
 
-  def apply_patch(self, patches, post_processors=None, verbose=False,
-                  name=None, email=None):
+  def apply_patch(self, patches, post_processors=None, verbose=False):
     """Applies a patch and returns the list of modified files.
 
     This function should throw patch.UnsupportedPatchFormat or
     PatchApplicationFailed when relevant.
 
     Args:
       patches: patch.PatchSet object.
     """
     raise NotImplementedError()
 
@@ skipping 13 matching lines @@
 
 class RawCheckout(CheckoutBase):
   """Used to apply a patch locally without any intent to commit it.
 
   To be used by the try server.
   """
   def prepare(self, revision):
     """Stubbed out."""
     pass
 
-  def apply_patch(self, patches, post_processors=None, verbose=False,
-                  name=None, email=None):
+  def apply_patch(self, patches, post_processors=None, verbose=False):
     """Ignores svn properties."""
     post_processors = post_processors or self.post_processors or []
     for p in patches:
       stdout = []
       try:
         filepath = os.path.join(self.project_path, p.filename)
         if p.is_delete:
           os.remove(filepath)
           stdout.append('Deleted.')
         else:
@@ skipping 163 matching lines @@
     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' %
           (self.project_name, self.project_path))
     return self._revert(revision)
 
-  def apply_patch(self, patches, post_processors=None, verbose=False,
-                  name=None, email=None):
+  def apply_patch(self, patches, post_processors=None, verbose=False):
     post_processors = post_processors or self.post_processors or []
     for p in patches:
       stdout = []
       try:
         filepath = os.path.join(self.project_path, p.filename)
         # It is important to use credentials=False otherwise credentials could
         # leak in the error message. Credentials are not necessary here for the
         # following commands anyway.
         if p.is_delete:
           stdout.append(self._check_output_svn(
@@ skipping 183 matching lines @@
           ['log', '-q', self.svn_url, '-r', '%s:%s' % (rev1, rev2)])
     except subprocess.CalledProcessError:
       return None
     # Ignore the '----' lines.
     return len([l for l in out.splitlines() if l.startswith('r')]) - 1
 
 
 class GitCheckout(CheckoutBase):
   """Manages a git checkout."""
   def __init__(self, root_dir, project_name, remote_branch, git_url,
-      commit_user, post_processors=None, base_ref=None):
+      commit_user, post_processors=None):
     super(GitCheckout, self).__init__(root_dir, project_name, post_processors)
-    self.base_ref = base_ref
     self.git_url = git_url
     self.commit_user = commit_user
     self.remote_branch = remote_branch
     # The working branch where patches will be applied. It will track the
     # remote branch.
     self.working_branch = 'working_branch'
     # There is no reason to not hardcode origin.
     self.remote = 'origin'
     # There is no reason to not hardcode master.
     self.master_branch = 'master'
@@ skipping 52 matching lines @@
         self.remote, self.remote_branch)
     self._check_call_git(
         ['pull', self.remote,
          '%s:%s' % (self.remote_branch, remote_tracked_path),
          '--quiet'])
 
   def _get_head_commit_hash(self):
     """Gets the current revision (in unicode) from the local branch."""
     return unicode(self._check_output_git(['rev-parse', 'HEAD']).strip())
 
-  def apply_patch(self, patches, post_processors=None, verbose=False,
-                  name=None, email=None):
+  def apply_patch(self, patches, post_processors=None, verbose=False):
     """Applies a patch on 'working_branch' and switches to it.
 
-    Also commits the changes on the local branch.
+    The changes remain staged on the current branch.
 
     Ignores svn properties and raise an exception on unexpected ones.
     """
     post_processors = post_processors or self.post_processors or []
     # It this throws, the checkout is corrupted. Maybe worth deleting it and
     # trying again?
     if self.remote_branch:
       self._check_call_git(
           ['checkout', '-b', self.working_branch, '-t', self.remote_branch,
            '--quiet'])
@@ skipping 53 matching lines @@
           print align_stdout(stdout)
       except OSError, e:
         raise PatchApplicationFailed(p, '%s%s' % (align_stdout(stdout), e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
             p,
             'While running %s;\n%s%s' % (
               ' '.join(e.cmd),
               align_stdout(stdout),
               align_stdout([getattr(e, 'stdout', '')])))
-    # Once all the patches are processed and added to the index, commit the
-    # index.
-    cmd = ['commit', '-m', 'Committed patch']
-    if name and email:
-      cmd = ['-c', 'user.email=%s' % email, '-c', 'user.name=%s' % name] + cmd
-    if verbose:
-      cmd.append('--verbose')
-    self._check_call_git(cmd)
-    if self.base_ref:
-      base_ref = self.base_ref
-    else:
-      base_ref = '%s/%s' % (self.remote,
-                            self.remote_branch or self.master_branch)
     found_files = self._check_output_git(
-        ['diff', base_ref, '--ignore-submodules',
-         '--name-only']).splitlines(False)
+        ['diff', '--ignore-submodules',
+         '--name-only', '--staged']).splitlines(False)
     assert sorted(patches.filenames) == sorted(found_files), (
         'Found extra %s locally, %s not patched' % (
             sorted(set(found_files) - set(patches.filenames)),
             sorted(set(patches.filenames) - set(found_files))))
 
   def commit(self, commit_message, user):
     """Commits, updates the commit message and pushes."""
+    # TODO(hinoka): CQ no longer uses this, I think its deprecated.
+    #               Delete this.
     assert self.commit_user
     assert isinstance(commit_message, unicode)
     current_branch = self._check_output_git(
         ['rev-parse', '--abbrev-ref', 'HEAD']).strip()
     assert current_branch == self.working_branch
 
-    commit_cmd = ['commit', '--amend', '-m', commit_message]
+    commit_cmd = ['commit', '-m', commit_message]
     if user and user != self.commit_user:
       # We do not have the first or last name of the user, grab the username
       # from the email and call it the original author's name.
       # TODO(rmistry): Do not need the below if user is already in
       #                "Name <email>" format.
       name = user.split('@')[0]
       commit_cmd.extend(['--author', '%s <%s>' % (name, user)])
     self._check_call_git(commit_cmd)
 
     # Push to the remote repository.
@@ skipping 67 matching lines @@
     self.checkout = checkout
     self.post_processors = (post_processors or []) + (
         self.checkout.post_processors or [])
 
   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, post_processors=None, verbose=False,
-                  name=None, email=None):
+  def apply_patch(self, patches, post_processors=None, verbose=False):
     return self.checkout.apply_patch(
         patches, post_processors or self.post_processors, verbose)
 
   def commit(self, message, user):  # pylint: disable=R0201
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   def revisions(self, rev1, rev2):
     return self.checkout.revisions(rev1, rev2)
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path