Make checkout.GitCheckout usable from apply_issue

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 536 matching lines @@
     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):
-    assert git_url
-    assert commit_user
     super(GitCheckout, self).__init__(root_dir, project_name, post_processors)
     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'
 
   def prepare(self, revision):
     """Resets the git repository in a clean state.
 
     Checks it out if not present and deletes the working branch.
     """
     assert self.remote_branch
+    assert self.git_url
 
     if not os.path.isdir(self.project_path):
       # Clone the repo if the directory is not present.
       logging.info(
           'Checking out %s in %s', self.project_name, self.project_path)
       self._check_call_git(
           ['clone', self.git_url, '-b', self.remote_branch, self.project_path],
           cwd=None, timeout=FETCH_TIMEOUT)
     else:
       # Throw away all uncommitted changes in the existing checkout.
       self._check_call_git(['checkout', self.remote_branch])
       self._check_call_git(
           ['reset', '--hard', '--quiet',
            '%s/%s' % (self.remote, self.remote_branch)])
 
     if revision:
       try:
         # Look if the commit hash already exist. If so, we can skip a
         # 'git fetch' call.
         revision = self._check_output_git(['rev-parse', revision])
       except subprocess.CalledProcessError:
         self._check_call_git(
             ['fetch', self.remote, self.remote_branch, '--quiet'])
         revision = self._check_output_git(['rev-parse', revision])
       self._check_call_git(['checkout', '--force', '--quiet', revision])
     else:
       branches, active = self._branches()
-      if active != 'master':
-        self._check_call_git(['checkout', '--force', '--quiet', 'master'])
+      if active != self.master_branch:
+        self._check_call_git(
+            ['checkout', '--force', '--quiet', self.master_branch])
       self._sync_remote_branch()
 
       if self.working_branch in branches:
         self._call_git(['branch', '-D', self.working_branch])
     return self._get_head_commit_hash()
 
   def _sync_remote_branch(self):
     """Syncs the remote branch."""
     # We do a 'git pull origin master:refs/remotes/origin/master' instead of
     # 'git pull origin master' because from the manpage for git-pull: 
@@ skipping 88 matching lines @@
               ' '.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 verbose:
       cmd.append('--verbose')
     self._check_call_git(cmd)
     found_files = self._check_output_git(
-        ['diff', '%s/%s' % (self.remote, self.remote_branch),
+        ['diff', '%s/%s' % (self.remote,
+                            self.remote_branch or self.master_branch),
          '--name-only']).splitlines(False)
     assert sorted(patches.filenames) == sorted(found_files), (
         sorted(patches.filenames), sorted(found_files))
 
   def commit(self, commit_message, user):
     """Commits, updates the commit message and pushes."""
+    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]
     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
@@ skipping 92 matching lines @@
   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