Include range summary when rolling into chromium.

tools/release/common_includes.py

 #!/usr/bin/env python
 # Copyright 2013 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
@@ skipping 29 matching lines @@
 import textwrap
 import time
 import urllib
 import urllib2
 
 from git_recipes import GitRecipesMixin
 from git_recipes import GitFailedException
 
 CHANGELOG_FILE = "ChangeLog"
 PUSH_MSG_GIT_RE = re.compile(r".* \(based on (?P<git_rev>[a-fA-F0-9]+)\)$")
+PUSH_MSG_NEW_RE = re.compile(r"^Version \d+\.\d+\.\d+$")
 VERSION_FILE = os.path.join("src", "version.cc")
 VERSION_RE = re.compile(r"^\d+\.\d+\.\d+(?:\.\d+)?$")
 
 # V8 base directory.
 V8_BASE = os.path.dirname(
     os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 def TextToFile(text, file_name):
   with open(file_name, "w") as f:
@@ skipping 524 matching lines @@
       print "> ",
       answer = self.ReadLine()
 
   # Takes a file containing the patch to apply as first argument.
   def ApplyPatch(self, patch_file, revert=False):
     try:
       self.GitApplyPatch(patch_file, revert)
     except GitFailedException:
       self.WaitForResolvingConflicts(patch_file)
 
+  def GetVersionTag(self, revision):
+    tag = self.Git("describe --tags %s" % revision).strip()
+    if VERSION_RE.match(tag):
+      return tag
+    else:
+      return None
+
   def GetRecentReleases(self, max_age):
     # Make sure tags are fetched.
     self.Git("fetch origin +refs/tags/*:refs/tags/*")
 
     # Current timestamp.
     time_now = int(self._side_effect_handler.GetUTCStamp())
 
     # List every tag from a given period.
     revisions = self.Git("rev-list --max-age=%d --tags" %
                          int(time_now - max_age)).strip()
 
-    def IsTagged(revision):
-      return VERSION_RE.match(
-          self.Git("describe --tags %s" % revision).strip())
-
     # Filter out revisions who's tag is off by one or more commits.
-    return filter(IsTagged, revisions.splitlines())
+    return filter(lambda r: self.GetVersionTag(r), revisions.splitlines())
 
   def GetLatestVersion(self):
     # Use cached version if available.
     if self["latest_version"]:
       return self["latest_version"]
 
     # Make sure tags are fetched.
     self.Git("fetch origin +refs/tags/*:refs/tags/*")
     version = sorted(filter(VERSION_RE.match, self.vc.GetTags()),
                      key=SortingKey, reverse=True)[0]
     self["latest_version"] = version
     return version
 
   def GetLatestRelease(self):
     """The latest release is the git hash of the latest tagged version.
 
     This revision should be rolled into chromium.
     """
     latest_version = self.GetLatestVersion()
 
     # The latest release.
     latest_hash = self.GitLog(n=1, format="%H", branch=latest_version)
     assert latest_hash
     return latest_hash
 
-  def GetLatestReleaseBase(self):
+  def GetLatestReleaseBase(self, version=None):
     """The latest release base is the latest revision that is covered in the
     last change log file. It doesn't include cherry-picked patches.
     """
-    latest_version = self.GetLatestVersion()
+    latest_version = version or self.GetLatestVersion()
 
     # Strip patch level if it exists.
     latest_version = ".".join(latest_version.split(".")[:3])
 
     # The latest release base.
     latest_hash = self.GitLog(n=1, format="%H", branch=latest_version)
     assert latest_hash
 
-    match = PUSH_MSG_GIT_RE.match(
-        self.GitLog(n=1, format="%s", git_hash=latest_hash))
+    title = self.GitLog(n=1, format="%s", git_hash=latest_hash)
+    match = PUSH_MSG_GIT_RE.match(title)
     if match:
       # Legacy: In the old process there's one level of indirection. The
       # version is on the candidates branch and points to the real release
       # base on master through the commit message.
-      latest_hash = match.group("git_rev")
-    return latest_hash

[Michael Achenbach, 2015/02/12 10:38:55]

Just returning here wouldn't be correct with the new branching strategy. It
would include the version file change commit on the branch. For calculating the
change log that makes no difference, but for the summary of rolled changes it is
cleaner to not show it in my opinion.

[tandrii(chromium), 2015/02/13 22:29:08]

Agree.

+      return match.group("git_rev")
+    match = PUSH_MSG_NEW_RE.match(title)
+    if match:
+      # This is a new-style v8 version branched from master. The commit
+      # "latest_hash" is the version-file change. Its parent is the release
+      # base on master.
+      return self.GitLog(n=1, format="%H", git_hash="%s^" % latest_hash)
+
+    self.Die("Unknown latest release: %s" % latest_hash)
 
   def ArrayToVersion(self, prefix):
     return ".".join([self[prefix + "major"],
                      self[prefix + "minor"],
                      self[prefix + "build"],
                      self[prefix + "patch"]])
 
   def StoreVersion(self, version, prefix):
     version_parts = version.split(".")
     if len(version_parts) == 3:
@@ skipping 195 matching lines @@
     for (number, step_class) in enumerate([BootstrapStep] + step_classes):
       steps.append(MakeStep(step_class, number, self._state, self._config,
                             options, self._side_effect_handler))
     for step in steps[options.step:]:
       if step.Run():
         return 0
     return 0
 
   def Run(self, args=None):
     return self.RunSteps(self._Steps(), args)