Pass in "--author 'name <email@somewhere.com>" when doing git patches in apply_issue.py

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):
+  def apply_patch(self, patches, post_processors=None, verbose=False,
+                  name=None, email=None):
     """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):
+  def apply_patch(self, patches, post_processors=None, verbose=False,
+                  name=None, email=None):
     """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):
+  def apply_patch(self, patches, post_processors=None, verbose=False,
+                  name=None, email=None):
     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 258 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):
+  def apply_patch(self, patches, post_processors=None, verbose=False, 
+                  name=None, email=None):
     """Applies a patch on 'working_branch' and switches to it.
 
     Also commits the changes on the local 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:
@@ skipping 59 matching lines @@
       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:
+      author = '%s <%s>' % (name, email)
+      cmd.extend(['--author', author])
     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,
@@ skipping 90 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):
+  def apply_patch(self, patches, post_processors=None, verbose=False,
+                  name=None, email=None):
     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