Make git cl patch work with binary files.

git_cl.py

 #!/usr/bin/env python
 # 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.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld and Gerrit."""
 
 from __future__ import print_function
@@ skipping 22 matching lines @@
 
 try:
   import readline  # pylint: disable=F0401,W0611
 except ImportError:
   pass
 
 from third_party import colorama
 from third_party import httplib2
 from third_party import upload
 import auth
+import checkout
 import clang_format
 import commit_queue
 import dart_format
 import setup_color
 import fix_encoding
 import gclient_utils
 import gerrit_util
 import git_cache
 import git_common
 import git_footers
@@ skipping 930 matching lines @@
   def __init__(self, issue=None, patchset=None, hostname=None):
     self.issue = issue
     self.patchset = patchset
     self.hostname = hostname
 
   @property
   def valid(self):
     return self.issue is not None
 
 
-class _RietveldParsedIssueNumberArgument(_ParsedIssueNumberArgument):
-  def __init__(self, *args, **kwargs):
-    self.patch_url = kwargs.pop('patch_url', None)
-    super(_RietveldParsedIssueNumberArgument, self).__init__(*args, **kwargs)
-
-
 def ParseIssueNumberArgument(arg):
   """Parses the issue argument and returns _ParsedIssueNumberArgument."""
   fail_result = _ParsedIssueNumberArgument()
 
   if arg.isdigit():
     return _ParsedIssueNumberArgument(issue=int(arg))
   if not arg.startswith('http'):
     return fail_result
   url = gclient_utils.UpgradeToHttps(arg)
   try:
@@ skipping 796 matching lines @@
         DieWithError(
             '\nFailed to fetch issue description. HTTP error %d' % e.code)
     except urllib2.URLError as e:
       print('Warning: Failed to retrieve CL description due to network '
             'failure.', file=sys.stderr)
       return ''
 
   def GetMostRecentPatchset(self):
     return self.GetIssueProperties()['patchsets'][-1]
 
-  def GetPatchSetDiff(self, issue, patchset):
-    return self.RpcServer().get(
-        '/download/issue%s_%s.diff' % (issue, patchset))
-
   def GetIssueProperties(self):
     if self._props is None:
       issue = self.GetIssue()
       if not issue:
         self._props = {}
       else:
         self._props = self.RpcServer().get_issue_properties(issue, True)
     return self._props
 
   def CannotTriggerTryJobReason(self):
@@ skipping 136 matching lines @@
       self.SetFlags({'commit': '1', 'cq_dry_run': '0'})
     elif new_state == _CQState.NONE:
       self.SetFlags({'commit': '0', 'cq_dry_run': '0'})
     else:
       assert new_state == _CQState.DRY_RUN
       self.SetFlags({'commit': '1', 'cq_dry_run': '1'})
 
 
   def CMDPatchWithParsedIssue(self, parsed_issue_arg, reject, nocommit,
                               directory):
-    # TODO(maruel): Use apply_issue.py
-
     # PatchIssue should never be called with a dirty tree.  It is up to the
     # caller to check this, but just in case we assert here since the
     # consequences of the caller not checking this could be dire.
     assert(not git_common.is_dirty_git_tree('apply'))
     assert(parsed_issue_arg.valid)
     self._changelist.issue = parsed_issue_arg.issue
     if parsed_issue_arg.hostname:
       self._rietveld_server = 'https://%s' % parsed_issue_arg.hostname
 
-    if (isinstance(parsed_issue_arg, _RietveldParsedIssueNumberArgument) and
-        parsed_issue_arg.patch_url):
-      assert parsed_issue_arg.patchset
-      patchset = parsed_issue_arg.patchset
-      patch_data = urllib2.urlopen(parsed_issue_arg.patch_url).read()
-    else:
-      patchset = parsed_issue_arg.patchset or self.GetMostRecentPatchset()
-      patch_data = self.GetPatchSetDiff(self.GetIssue(), patchset)
-
-    # Switch up to the top-level directory, if necessary, in preparation for
-    # applying the patch.
-    top = settings.GetRelativeRoot()
-    if top:
-      os.chdir(top)
-
-    # Git patches have a/ at the beginning of source paths.  We strip that out
-    # with a sed script rather than the -p flag to patch so we can feed either
-    # Git or svn-style patches into the same apply command.
-    # re.sub() should be used but flags=re.MULTILINE is only in python 2.7.
+    patchset = parsed_issue_arg.patchset or self.GetMostRecentPatchset()
+    patchset_object = self.RpcServer().get_patch(self.GetIssue(), patchset)
+    scm_obj = checkout.GitCheckout(settings.GetRoot(), None, None, None, None)
     try:
-      patch_data = subprocess2.check_output(
-          ['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'], stdin=patch_data)
-    except subprocess2.CalledProcessError:
-      DieWithError('Git patch mungling failed.')
-    logging.info(patch_data)
-
-    # We use "git apply" to apply the patch instead of "patch" so that we can
-    # pick up file adds.
-    # The --index flag means: also insert into the index (so we catch adds).
-    cmd = ['git', 'apply', '--index', '-p0']
-    if directory:
-      cmd.extend(('--directory', directory))
-    if reject:
-      cmd.append('--reject')
-    elif IsGitVersionAtLeast('1.7.12'):
-      cmd.append('--3way')
-    try:
-      subprocess2.check_call(cmd, env=GetNoGitPagerEnv(),
-                             stdin=patch_data, stdout=subprocess2.VOID)
-    except subprocess2.CalledProcessError:
-      print('Failed to apply the patch')
+      scm_obj.apply_patch(patchset_object)
+    except Exception as e:
+      print(str(e))
       return 1
 
     # If we had an issue, commit the current state and register the issue.
     if not nocommit:
       RunGit(['commit', '-m', (self.GetDescription() + '\n\n' +
                                'patch from issue %(i)s at patchset '
                                '%(p)s (http://crrev.com/%(i)s#ps%(p)s)'
                                % {'i': self.GetIssue(), 'p': patchset})])
       self.SetIssue(self.GetIssue())
       self.SetPatchset(patchset)
       print('Committed patch locally.')
     else:
       print('Patch applied to index.')
     return 0
 
   @staticmethod
   def ParseIssueURL(parsed_url):
     if not parsed_url.scheme or not parsed_url.scheme.startswith('http'):
       return None
     # Rietveld patch: https://domain/<number>/#ps<patchset>
     match = re.match(r'/(\d+)/$', parsed_url.path)
     match2 = re.match(r'ps(\d+)$', parsed_url.fragment)
     if match and match2:
-      return _RietveldParsedIssueNumberArgument(
+      return _ParsedIssueNumberArgument(
           issue=int(match.group(1)),
           patchset=int(match2.group(1)),
           hostname=parsed_url.netloc)
     # Typical url: https://domain/<issue_number>[/[other]]
     match = re.match('/(\d+)(/.*)?$', parsed_url.path)
     if match:
-      return _RietveldParsedIssueNumberArgument(
+      return _ParsedIssueNumberArgument(
           issue=int(match.group(1)),
           hostname=parsed_url.netloc)
     # Rietveld patch: https://domain/download/issue<number>_<patchset>.diff
     match = re.match(r'/download/issue(\d+)_(\d+).diff$', parsed_url.path)
     if match:
-      return _RietveldParsedIssueNumberArgument(
+      return _ParsedIssueNumberArgument(
           issue=int(match.group(1)),
           patchset=int(match.group(2)),
-          hostname=parsed_url.netloc,
-          patch_url=gclient_utils.UpgradeToHttps(parsed_url.geturl()))
+          hostname=parsed_url.netloc)
     return None
 
   def CMDUploadChange(self, options, args, change):
     """Upload the patch to Rietveld."""
     upload_args = ['--assume_yes']  # Don't ask about untracked files.
     upload_args.extend(['--server', self.GetCodereviewServer()])
     upload_args.extend(auth.auth_config_to_command_options(self._auth_config))
     if options.emulate_svn_auto_props:
       upload_args.append('--emulate_svn_auto_props')
 
@@ skipping 3336 matching lines @@
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   setup_color.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)