Store hashes of current and previous shipped V8 version

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 42 matching lines @@
 DEPS_RE = re.compile(r"""^\s*(?:["']v8_revision["']: ["']"""
                      """|\(Var\("googlecode_url"\) % "v8"\) \+ "\/trunk@"""
                      """|"http\:\/\/v8\.googlecode\.com\/svn\/trunk@)"""
                      """([^"']+)["'].*$""", re.M)
 
 # Expression to pick tag and revision for bleeding edge tags. To be used with
 # output of 'svn log'.
 BLEEDING_EDGE_TAGS_RE = re.compile(
     r"A \/tags\/([^\s]+) \(from \/branches\/bleeding_edge\:(\d+)\)")
 
+OMAHA_PROXY_URL = "http://omahaproxy.appspot.com/"
 
 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.
 
@@ skipping 360 matching lines @@
       releases_dict.get(revision, {})["chromium_branch"] = ranges
 
 
 class RetrieveInformationOnChromeReleases(Step):
   MESSAGE = 'Retrieves relevant information on the latest Chrome releases'
 
   def Run(self):
 
     params = None
     result_raw = self.ReadURL(
-                             "http://omahaproxy.appspot.com/all.json",
+                             OMAHA_PROXY_URL + "all.json",
                              params,
                              wait_plan=[5, 20]
                              )
     recent_releases = json.loads(result_raw)
 
     canaries = []
 
     for current_os in recent_releases:
       for current_version in current_os["versions"]:
-        current_candidate = {
-                            "chrome_version": current_version["version"],
-                           "os": current_version["os"],
-                           "release_date": current_version["current_reldate"],
-                           "v8_version": current_version["v8_version"],
-                           }
+        if current_version["channel"] != "canary":
+          continue
 
-        if current_version["channel"] == "canary":
-          canaries.append(current_candidate)
+        current_candidate = self._CreateCandidate(current_version)
+        canaries.append(current_candidate)
 
     chrome_releases = {"canaries": canaries}
     self["chrome_releases"] = chrome_releases
 
+  def _GetGitHashForV8Version(self, v8_version):
+    if v8_version.split(".")[3]== "0":
+      return self.GitGetHashOfTag(v8_version[:-2])
+
+    return self.GitGetHashOfTag(v8_version)
+
+  def _CreateCandidate(self, current_version):
+    params = None
+    url_to_call = (OMAHA_PROXY_URL + "v8.json?version="
+                   + current_version["previous_version"])
+    result_raw = self.ReadURL(
+                         url_to_call,
+                         params,
+                         wait_plan=[5, 20]
+                         )
+    previous_v8_version = json.loads(result_raw)["v8_version"]
+    v8_previous_version_hash = self._GetGitHashForV8Version(previous_v8_version)
+
+    current_v8_version = current_version["v8_version"]
+    v8_version_hash = self._GetGitHashForV8Version(current_v8_version)
+
+    current_candidate = {
+                        "chrome_version": current_version["version"],
+                        "os": current_version["os"],
+                        "release_date": current_version["current_reldate"],
+                        "v8_version": current_v8_version,
+                        "v8_version_hash": v8_version_hash,
+                        "v8_previous_version": previous_v8_version,
+                        "v8_previous_version_hash": v8_previous_version_hash,
+                       }
+    return current_candidate
+
 
 class CleanUp(Step):
   MESSAGE = "Clean up."
 
   def RunStep(self):
     self.CommonCleanup()
 
 
 class WriteOutput(Step):
   MESSAGE = "Print output."
@@ skipping 55 matching lines @@
       RetrieveChromiumV8Releases,
       RetrieveChromiumBranches,
       RetrieveInformationOnChromeReleases,
       CleanUp,
       WriteOutput,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Releases().Run())