Switch v8 mirror in version script.

tools/push-to-trunk/bump_up_version.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 Script for auto-increasing the version on bleeding_edge.
 
 The script can be run regularly by a cron job. It will increase the build
 level of the version on bleeding_edge if:
@@ skipping 19 matching lines @@
 
 class Preparation(Step):
   MESSAGE = "Preparation."
 
   def RunStep(self):
     # Check for a clean workdir.
     if not self.GitIsWorkdirClean():  # pragma: no cover
       # This is in case a developer runs this script on a dirty tree.
       self.GitStash()
 
-    # TODO(machenbach): This should be called master after the git switch.
-    self.GitCheckout("bleeding_edge")
+    self.GitCheckout("master")
 
     self.GitPull()
 
     # Ensure a clean version branch.
     self.DeleteBranch(VERSION_BRANCH)
 
 
 class GetCurrentBleedingEdgeVersion(Step):
   MESSAGE = "Get latest bleeding edge version."
 
   def RunStep(self):
-    # TODO(machenbach): This should be called master after the git switch.
-    self.GitCheckout("bleeding_edge")
+    self.GitCheckout("master")
 
     # Store latest version and revision.
     self.ReadAndPersistVersion()
     self["latest_version"] = self.ArrayToVersion("")
     self["latest"] = self.GitLog(n=1, format="%H")
     print "Bleeding edge version: %s" % self["latest_version"]
 
 
 # This step is pure paranoia. It forbids the script to continue if the last
 # commit changed version.cc. Just in case the other bailout has a bug, this
@@ skipping 16 matching lines @@
     self["lkgr_svn"] = self.ReadURL(lkgr_url, wait_plan=[5])
 
 
 # TODO(machenbach): Implement this for git. With a git lkgr we could simply
 # checkout that revision. With svn, we have to search backwards until that
 # revision is found.
 class GetLKGRVersion(Step):
   MESSAGE = "Get bleeding edge lkgr version."
 
   def RunStep(self):
-    self.GitCheckout("bleeding_edge")
+    self.GitCheckout("master")
     # If the commit was made from svn, there is a mapping entry in the commit
     # message.
     self["lkgr"] = self.GitLog(
         grep="^git-svn-id: [^@]*@%s [A-Za-z0-9-]*$" % self["lkgr_svn"],
         format="%H")
 
     # FIXME(machenbach): http://crbug.com/391712 can lead to svn lkgrs on the
     # trunk branch (rarely).
     if not self["lkgr"]:  # pragma: no cover
       self.Die("No git hash found for svn lkgr.")
 
     self.GitCreateBranch(VERSION_BRANCH, self["lkgr"])
     self.ReadAndPersistVersion("lkgr_")
     self["lkgr_version"] = self.ArrayToVersion("lkgr_")
     print "LKGR version: %s" % self["lkgr_version"]
 
     # Ensure a clean version branch.
-    self.GitCheckout("bleeding_edge")
+    self.GitCheckout("master")
     self.DeleteBranch(VERSION_BRANCH)
 
 
 class LKGRVersionUpToDateBailout(Step):
   MESSAGE = "Stop script if the lkgr has a renewed version."
 
   def RunStep(self):
     # If a version-change commit becomes the lkgr, don't bump up the version
     # again.
     if VERSION_FILE in self.GitChangedFiles(self["lkgr"]):
       print "Stop because the lkgr is a version change itself."
       return True
 
     # Don't bump up the version if it got updated already after the lkgr.
     if SortingKey(self["lkgr_version"]) < SortingKey(self["latest_version"]):
       print("Stop because the latest version already changed since the lkgr "
             "version.")
       return True
 
 
 class GetTrunkVersion(Step):
   MESSAGE = "Get latest trunk version."
 
   def RunStep(self):
-    # TODO(machenbach): This should be called trunk after the git switch.
-    self.GitCheckout("master")
+    self.GitCheckout("candidates")
     self.GitPull()
     self.ReadAndPersistVersion("trunk_")
     self["trunk_version"] = self.ArrayToVersion("trunk_")
     print "Trunk version: %s" % self["trunk_version"]
 
 
 class CalculateVersion(Step):
   MESSAGE = "Calculate the new version."
 
   def RunStep(self):
@@ skipping 33 matching lines @@
     message = json.loads(status_json)["message"]
     if re.search(r"maintenance|no commits", message, flags=re.I):
       print "Skip version change by tree status: \"%s\"" % message
       return True
 
 
 class ChangeVersion(Step):
   MESSAGE = "Bump up the version."
 
   def RunStep(self):
-    self.GitCreateBranch(VERSION_BRANCH, "bleeding_edge")
+    self.GitCreateBranch(VERSION_BRANCH, "master")
 
     self.SetVersion(os.path.join(self.default_cwd, VERSION_FILE), "new_")
 
     try:
       msg = "[Auto-roll] Bump up version to %s" % self["new_version"]
       self.GitCommit("%s\n\nTBR=%s" % (msg, self._options.author),
                      author=self._options.author)
       if self._options.svn:
         self.SVNCommit("branches/bleeding_edge", msg)
       else:
         self.GitUpload(author=self._options.author,
                        force=self._options.force_upload,
                        bypass_hooks=True)
         self.GitDCommit()
       print "Successfully changed the version."
     finally:
       # Clean up.
-      self.GitCheckout("bleeding_edge")
+      self.GitCheckout("master")
       self.DeleteBranch(VERSION_BRANCH)
 
 
 class BumpUpVersion(ScriptsBase):
   def _PrepareOptions(self, parser):
     parser.add_argument("--dry_run", help="Don't commit the new version.",
                         default=False, action="store_true")
 
   def _ProcessOptions(self, options):  # pragma: no cover
     if not options.dry_run and not options.author:
@@ skipping 18 matching lines @@
       GetLKGRVersion,
       LKGRVersionUpToDateBailout,
       GetTrunkVersion,
       CalculateVersion,
       CheckTreeStatus,
       ChangeVersion,
     ]
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(BumpUpVersion().Run())