Fix v8rel script after adding roll branches.

tools/release/releases.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.
 
 # This script retrieves the history of all V8 branches and
 # their corresponding Chromium revisions.
 
 # Requires a chromium checkout with branch heads:
 # gclient sync --with_branch_heads
@@ skipping 52 matching lines @@
 
 def SortBranches(branches):
   """Sort branches with version number names."""
   return sorted(branches, key=SortingKey, reverse=True)
 
 
 def FilterDuplicatesAndReverse(cr_releases):
   """Returns the chromium releases in reverse order filtered by v8 revision
   duplicates.
 
-  cr_releases is a list of [cr_rev, v8_rev] reverse-sorted by cr_rev.
+  cr_releases is a list of [cr_rev, v8_hsh] reverse-sorted by cr_rev.
   """
   last = ""
   result = []
   for release in reversed(cr_releases):
     if last == release[1]:
       continue
     last = release[1]
     result.append(release)
   return result
 
 
 def BuildRevisionRanges(cr_releases):
   """Returns a mapping of v8 revision -> chromium ranges.
   The ranges are comma-separated, each range has the form R1:R2. The newest
   entry is the only one of the form R1, as there is no end range.
 
-  cr_releases is a list of [cr_rev, v8_rev] reverse-sorted by cr_rev.
-  cr_rev either refers to a chromium svn revision or a chromium branch number.
+  cr_releases is a list of [cr_rev, v8_hsh] reverse-sorted by cr_rev.
+  cr_rev either refers to a chromium commit position or a chromium branch
+  number.
   """
   range_lists = {}
   cr_releases = FilterDuplicatesAndReverse(cr_releases)
 
   # Visit pairs of cr releases from oldest to newest.
   for cr_from, cr_to in itertools.izip(
       cr_releases, itertools.islice(cr_releases, 1, None)):
 
     # Assume the chromium revisions are all different.
     assert cr_from[0] != cr_to[0]
 
-    # TODO(machenbach): Subtraction is not git friendly.
     ran = "%s:%d" % (cr_from[0], int(cr_to[0]) - 1)
 
     # Collect the ranges in lists per revision.
     range_lists.setdefault(cr_from[1], []).append(ran)
 
   # Add the newest revision.
   if cr_releases:
     range_lists.setdefault(cr_releases[-1][1], []).append(cr_releases[-1][0])
 
   # Stringify and comma-separate the range lists.
-  return dict((rev, ", ".join(ran)) for rev, ran in range_lists.iteritems())
+  return dict((hsh, ", ".join(ran)) for hsh, ran in range_lists.iteritems())
 
 
 def MatchSafe(match):
   if match:
     return match.group(1)
   else:
     return ""
 
 
 class Preparation(Step):
@@ skipping 75 matching lines @@
     body = self.GitLog(n=1, format="%B", git_hash=git_hash)
 
     patches = ""
     if self["patch"] != "0":
       version += ".%s" % self["patch"]
       if CHERRY_PICK_TITLE_GIT_RE.match(body.splitlines()[0]):
         patches = self.GetMergedPatchesGit(body)
       else:
         patches = self.GetMergedPatches(body)
 
-    title = self.GitLog(n=1, format="%s", git_hash=git_hash)
-    master_hash = self.GetMasterHashFromPush(title)
+    if SortingKey("4.2.69") <= SortingKey(version):
+      master_hash = self.GetLatestReleaseBase(version=version)
+    else:
+      # Legacy: Before version 4.2.69, the master revision was determined
+      # by commit message.
+      title = self.GitLog(n=1, format="%s", git_hash=git_hash)
+      master_hash = self.GetMasterHashFromPush(title)
     master_position = ""
     if master_hash:
       master_position = self.GetCommitPositionNumber(master_hash)
-    # TODO(machenbach): Add the commit position number.
     return self.GetReleaseDict(
         git_hash, master_position, master_hash, branch, version,
         patches, body), self["patch"]
 
   def GetReleasesFromBranch(self, branch):
     self.GitReset(self.vc.RemoteBranch(branch))
     if branch == self.vc.MasterBranch():
       return self.GetReleasesFromMaster()
 
     releases = []
@@ skipping 31 matching lines @@
           not self.GitCheckoutFileSafe(VERSION_FILE, revision)):
         print "Skipping revision %s" % revision
         return []  # pragma: no cover
 
       branches = map(
           str.strip,
           self.Git("branch -r --contains %s" % revision).strip().splitlines(),
       )
       branch = ""
       for b in branches:
-        if b == "origin/candidates":
-          branch = "candidates"
+        if b.startswith("origin/"):
+          branch = b.split("origin/")[1]
           break
         if b.startswith("branch-heads/"):
           branch = b.split("branch-heads/")[1]
           break
       else:
         print "Could not determine branch for %s" % revision
 
       release, _ = self.GetRelease(revision, branch)
       releases.append(release)
 
@@ skipping 60 matching lines @@
     return revision
   return step.GetCommitPositionNumber(
       revision, cwd=os.path.join(step._options.chromium, "v8"))
 
 
 class RetrieveChromiumV8Releases(Step):
   MESSAGE = "Retrieve V8 releases from Chromium DEPS."
 
   def RunStep(self):
     cwd = self._options.chromium
-    releases = filter(
-        lambda r: r["branch"] in [self.vc.CandidateBranch(),
-                                  self.vc.MasterBranch()],
-        self["releases"])
-    if not releases:  # pragma: no cover
-      print "No releases detected. Skipping chromium history."
-      return True
 
     # Update v8 checkout in chromium.
     self.GitFetchOrigin(cwd=os.path.join(cwd, "v8"))
 
-    oldest_v8_rev = int(releases[-1]["revision"])
+    # All v8 revisions we are interested in.
+    releases_dict = dict((r["revision_git"], r) for r in self["releases"])
 
     cr_releases = []
     try:
       for git_hash in self.GitLog(
           format="%H", grep="V8", cwd=cwd).splitlines():
         if "DEPS" not in self.GitChangedFiles(git_hash, cwd=cwd):
           continue
         if not self.GitCheckoutFileSafe("DEPS", git_hash, cwd=cwd):
           break  # pragma: no cover
         deps = FileToText(os.path.join(cwd, "DEPS"))
         match = DEPS_RE.search(deps)
         if match:
           cr_rev = self.GetCommitPositionNumber(git_hash, cwd=cwd)
           if cr_rev:
-            v8_rev = ConvertToCommitNumber(self, match.group(1))
-            cr_releases.append([cr_rev, v8_rev])
+            v8_hsh = match.group(1)
+            cr_releases.append([cr_rev, v8_hsh])
 
-          # Stop after reaching beyond the last v8 revision we want to update.
-          # We need a small buffer for possible revert/reland frenzies.
-          # TODO(machenbach): Subtraction is not git friendly.
-          if int(v8_rev) < oldest_v8_rev - 100:
+          # Stop as soon as we find a v8 revision that we didn't fetch in the
+          # v8-revision-retrieval part above (i.e. a revision that's too old).
+          if v8_hsh not in releases_dict:
             break  # pragma: no cover
 
     # Allow Ctrl-C interrupt.
     except (KeyboardInterrupt, SystemExit):  # pragma: no cover
       pass
 
     # Clean up.
     self.GitCheckoutFileSafe("DEPS", "HEAD", cwd=cwd)
 
     # Add the chromium ranges to the v8 candidates and master releases.
     all_ranges = BuildRevisionRanges(cr_releases)
-    releases_dict = dict((r["revision"], r) for r in releases)
-    for revision, ranges in all_ranges.iteritems():
-      releases_dict.get(revision, {})["chromium_revision"] = ranges
+
+    for hsh, ranges in all_ranges.iteritems():
+      releases_dict.get(hsh, {})["chromium_revision"] = ranges
 
 
 # TODO(machenbach): Unify common code with method above.
 class RietrieveChromiumBranches(Step):
   MESSAGE = "Retrieve Chromium branch information."
 
   def RunStep(self):
     cwd = self._options.chromium
-    cand_releases = filter(lambda r: r["branch"] == self.vc.CandidateBranch(),
-                           self["releases"])
-    if not cand_releases:  # pragma: no cover
-      print "No candidates releases detected. Skipping chromium history."
-      return True
 
-    oldest_v8_rev = int(cand_releases[-1]["revision"])
+    # All v8 revisions we are interested in.
+    releases_dict = dict((r["revision_git"], r) for r in self["releases"])
 
     # Filter out irrelevant branches.
     branches = filter(lambda r: re.match(r"branch-heads/\d+", r),
                       self.GitRemotes(cwd=cwd))
 
     # Transform into pure branch numbers.
     branches = map(lambda r: int(re.match(r"branch-heads/(\d+)", r).group(1)),
                    branches)
 
     branches = sorted(branches, reverse=True)
 
     cr_branches = []
     try:
       for branch in branches:
         if not self.GitCheckoutFileSafe("DEPS",
                                         "branch-heads/%d" % branch,
                                         cwd=cwd):
           break  # pragma: no cover
         deps = FileToText(os.path.join(cwd, "DEPS"))
         match = DEPS_RE.search(deps)
         if match:
-          v8_rev = ConvertToCommitNumber(self, match.group(1))
-          cr_branches.append([str(branch), v8_rev])
+          v8_hsh = match.group(1)
+          cr_branches.append([str(branch), v8_hsh])
 
-          # Stop after reaching beyond the last v8 revision we want to update.
-          # We need a small buffer for possible revert/reland frenzies.
-          # TODO(machenbach): Subtraction is not git friendly.
-          if int(v8_rev) < oldest_v8_rev - 100:
+          # Stop as soon as we find a v8 revision that we didn't fetch in the
+          # v8-revision-retrieval part above (i.e. a revision that's too old).
+          if v8_hsh not in releases_dict:
             break  # pragma: no cover
 
     # Allow Ctrl-C interrupt.
     except (KeyboardInterrupt, SystemExit):  # pragma: no cover
       pass
 
     # Clean up.
     self.GitCheckoutFileSafe("DEPS", "HEAD", cwd=cwd)
 
     # Add the chromium branches to the v8 candidate releases.
     all_ranges = BuildRevisionRanges(cr_branches)
-    cand_dict = dict((r["revision"], r) for r in cand_releases)
     for revision, ranges in all_ranges.iteritems():
-      cand_dict.get(revision, {})["chromium_branch"] = ranges
+      releases_dict.get(revision, {})["chromium_branch"] = ranges
 
 
 class CleanUp(Step):
   MESSAGE = "Clean up."
 
   def RunStep(self):
     self.GitCheckout("master", cwd=self._options.chromium)
     self.GitDeleteBranch(self.Config("BRANCHNAME"), cwd=self._options.chromium)
     self.CommonCleanup()
 
@@ skipping 50 matching lines @@
       UpdateChromiumCheckout,
       RetrieveChromiumV8Releases,
       RietrieveChromiumBranches,
       CleanUp,
       WriteOutput,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Releases().Run())