Have the ability for the PFQ to both rev Chrome and other packages.

cros_mark_as_stable.py

 #!/usr/bin/python
 
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This module uprevs a given package's ebuild to the next revision."""
 
 
 import fileinput
@@ skipping 148 matching lines @@
       # Add stable ebuilds to overlays[overlay].
       paths = [os.path.join(package_dir, path) for path in files]
       ebuild = _FindUprevCandidates(paths)
 
       # If the --all option isn't used, we only want to update packages that
       # are in packages.
       if ebuild and (all or ebuild.package in packages):
         overlays[overlay].append(ebuild)
 
 
-def _CheckOnStabilizingBranch(stable_branch):
-  """Returns true if the git branch is on the stabilizing branch."""
+def _DoWeHaveLocalCommits(stable_branch, tracking_branch):
+  """Returns true if there are local commits."""
   current_branch = _SimpleRunCommand('git branch | grep \*').split()[1]
-  return current_branch == stable_branch
+  if current_branch == stable_branch:
+    current_commit_id = _SimpleRunCommand('git rev-parse HEAD')
+    tracking_commit_id = _SimpleRunCommand('git rev-parse %s' % tracking_branch)
+    return current_commit_id != tracking_commit_id
+  else:
+    return False
 
 
 def _CheckSaneArguments(package_list, command):
   """Checks to make sure the flags are sane.  Dies if arguments are not sane."""
   if not command in COMMAND_DICTIONARY.keys():
     _PrintUsageAndDie('%s is not a valid command' % command)
   if not gflags.FLAGS.packages and command == 'commit' and not gflags.FLAGS.all:
     _PrintUsageAndDie('Please specify at least one package')
   if not gflags.FLAGS.board and command == 'commit':
     _PrintUsageAndDie('Please specify a board')
@@ skipping 33 matching lines @@
 # ======================= End Global Helper Functions ========================
 
 
 def Clean(tracking_branch):
   """Cleans up uncommitted changes.
 
   Args:
     tracking_branch:  The tracking branch we want to return to after the call.
   """
   _SimpleRunCommand('git reset HEAD --hard')
-  _SimpleRunCommand('git checkout %s' % tracking_branch)
+  branch = GitBranch(STABLE_BRANCH_NAME, tracking_branch)
+  if branch.Exists():
+    GitBranch.Checkout(branch)
+    branch.Delete()
 
 
 def PushChange(stable_branch, tracking_branch):
   """Pushes commits in the stable_branch to the remote git repository.
 
   Pushes locals commits from calls to CommitChange to the remote git
   repository specified by current working directory.
 
   Args:
     stable_branch: The local branch with commits we want to push.
     tracking_branch: The tracking branch of the local branch.
   Raises:
       OSError: Error occurred while pushing.
   """
   num_retries = 5
 
   # Sanity check to make sure we're on a stabilizing branch before pushing.
-  if not _CheckOnStabilizingBranch(stable_branch):
-    Info('Not on branch %s so no work found to push.  Exiting' % stable_branch)
+  if not _DoWeHaveLocalCommits(stable_branch, tracking_branch):
+    Info('Not work found to push.  Exiting')
     return
 
   description = _SimpleRunCommand('git log --format=format:%s%n%n%b ' +
                                   tracking_branch + '..')
   description = 'Marking set of ebuilds as stable\n\n%s' % description
   Info('Using description %s' % description)
   merge_branch_name = 'merge_branch'
   for push_try in range(num_retries + 1):
     try:
       _SimpleRunCommand('repo sync .')
       merge_branch = GitBranch(merge_branch_name, tracking_branch)
+      if merge_branch.Exists():
+        merge_branch.Delete()
       merge_branch.CreateBranch()
       if not merge_branch.Exists():
         Die('Unable to create merge branch.')
       _SimpleRunCommand('git merge --squash %s' % stable_branch)
       _SimpleRunCommand('git commit -m "%s"' % description)
       _SimpleRunCommand('git config push.default tracking')
       if gflags.FLAGS.dryrun:
         _SimpleRunCommand('git push --dry-run')
       else:
         _SimpleRunCommand('git push')
 
       break
     except:
       if push_try < num_retries:
         Warning('Failed to push change, performing retry (%s/%s)' % (
             push_try + 1, num_retries))
       else:
         raise
 
 
 class GitBranch(object):
   """Wrapper class for a git branch."""
 
   def __init__(self, branch_name, tracking_branch):
     """Sets up variables but does not create the branch."""
     self.branch_name = branch_name
     self.tracking_branch = tracking_branch
 
   def CreateBranch(self):
-    """Creates a new git branch or replaces an existing one."""
-    if self.Exists():
-      self.Delete()
-    self._Checkout(self.branch_name)
+    GitBranch.Checkout(self)
 
-  def _Checkout(self, target, create=True):
-    """Function used internally to create and move between branches."""
-    if create:
-      git_cmd = 'git checkout -b %s %s' % (target, self.tracking_branch)
+  @classmethod
+  def Checkout(cls, target):
+    """Function used to check out to another GitBranch."""
+    if target.branch_name == target.tracking_branch or target.Exists():
+      git_cmd = 'git checkout %s' % target.branch_name
     else:
-      git_cmd = 'git checkout %s' % target
+      git_cmd = 'git checkout -b %s %s' % (target.branch_name,
+                                           target.tracking_branch)
     _SimpleRunCommand(git_cmd)
 
   def Exists(self):
     """Returns True if the branch exists."""
     branch_cmd = 'git branch'
     branches = _SimpleRunCommand(branch_cmd)
     return self.branch_name in branches.split()
 
   def Delete(self):
     """Deletes the branch and returns the user to the master branch.
 
     Returns True on success.
     """
-    self._Checkout(self.tracking_branch, create=False)
+    tracking_branch = GitBranch(self.tracking_branch, self.tracking_branch)
+    GitBranch.Checkout(tracking_branch)
     delete_cmd = 'git branch -D %s' % self.branch_name
     _SimpleRunCommand(delete_cmd)
 
 
 class EBuild(object):
   """Wrapper class for information about an ebuild."""
 
   def __init__(self, path):
     """Sets up data about an ebuild from its path."""
     from portage.versions import pkgsplit
@@ skipping 242 matching lines @@
             message = _GIT_COMMIT_MESSAGE % (ebuild.package, commit_id)
             worker.CommitChange(message)
             revved_packages.append(ebuild.package)
             new_package_atoms.append('=%s' % new_package)
         except (OSError, IOError):
           Warning('Cannot rev %s\n' % ebuild.package,
                   'Note you will have to go into %s '
                   'and reset the git repo yourself.' % overlay)
           raise
 
-      if revved_packages:
-        _CleanStalePackages(gflags.FLAGS.board, new_package_atoms)
-        if gflags.FLAGS.drop_file:
-          fh = open(gflags.FLAGS.drop_file, 'w')
-          fh.write(' '.join(revved_packages))
-          fh.close()
-      else:
-        work_branch.Delete()
+      _CleanStalePackages(gflags.FLAGS.board, new_package_atoms)
+      if gflags.FLAGS.drop_file:
+        fh = open(gflags.FLAGS.drop_file, 'w')
+        fh.write(' '.join(revved_packages))
+        fh.close()
 
 
 if __name__ == '__main__':
   main(sys.argv)