Compute all version numbers using cef_version.py (see issue #2596)

The version format can now be controlled by setting the CEF_OLD_VERSION_FORMAT
environment variable. The old format is currently the default.

tools/cef_version.py

@@ -0,0 +1,266 @@
+# Copyright (c) 2019 The Chromium Embedded Framework Authors. All rights
+# reserved. Use of this source code is governed by a BSD-style license that
+# can be found in the LICENSE file.
+
+from file_util import *
+import git_util as git
+import os
+
+
+class VersionFormatter:
+  """ Formats CEF version information. """
+
+  def __init__(self, chromium_src_path=None):
+    if chromium_src_path is None:
+      # Relative to the current directory.
+      script_path = os.path.abspath(os.path.dirname(__file__))
+      chromium_src_path = os.path.abspath(
+          os.path.join(script_path, os.pardir, os.pardir))
+
+    self.src_path = chromium_src_path
+    assert os.path.isdir(self.src_path), self.src_path
+    self.cef_path = os.path.join(self.src_path, 'cef')
+    assert os.path.isdir(self.cef_path), self.cef_path
+
+    # Whether to use the old version format by default.
+    self._old_format_default = \
+        bool(int(os.environ.get('CEF_OLD_VERSION_FORMAT', '1')))
+
+    self.reset()
+
+  def reset(self):
+    """ Reset internal state. """
+    self._chrome_version = {}
+    self._cef_version = {}
+    self._cef_commit = {}
+    self._branch_version = {}
+    self._old_version_string = None
+    self._old_version_parts = {}
+    self._version_string = None
+    self._version_parts = {}
+
+  def get_chrome_version_components(self):
+    """ Returns Chrome version components. """
+    if not bool(self._chrome_version):
+      file_path = os.path.join(self.src_path, 'chrome', 'VERSION')
+      assert os.path.isfile(file_path), file_path
+      read_version_file(file_path, self._chrome_version)
+    return self._chrome_version
+
+  def get_cef_version_components(self):
+    """ Returns CEF version components. """
+    if not bool(self._cef_version):
+      file_path = os.path.join(self.cef_path, 'VERSION.in')
+      assert os.path.isfile(file_path), file_path
+      read_version_file(file_path, self._cef_version)
+    return self._cef_version
+
+  def get_cef_commit_components(self):
+    """ Returns CEF commit components. """
+    if not bool(self._cef_commit):
+      hash = git.get_hash(self.cef_path)
+      number = git.get_commit_number(self.cef_path)
+      self._cef_commit = {'HASH': hash, 'NUMBER': number}
+    return self._cef_commit
+
+  def get_cef_branch_version_components(self):
+    """ Computes the CEF branch version. """
+    if not bool(self._branch_version):
+      minor = 0
+      bugfix = 0
+
+      # Retrieve the list of commits that have been applied on the current
+      # branch since branching from origin/master.
+      hashes = git.get_branch_hashes(self.cef_path)
+      for hash in hashes:
+        # Determine if the API hash file was modified by the commit.
+        found = False
+        files = git.get_changed_files(self.cef_path, hash)
+        for file in files:
+          if file.find('cef_api_hash.h') >= 0:
+            found = True
+            break
+
+        if found:
+          minor += 1
+          bugfix = 0
+        else:
+          bugfix += 1
+
+      self._branch_version = {'MINOR': minor, 'PATCH': bugfix}
+    return self._branch_version
+
+  def get_chromium_version_string(self):
+    """ Returns the Chromium version number string. """
+    chrome_version = self.get_chrome_version_components()
+    return '%s.%s.%s.%s' % (chrome_version['MAJOR'], chrome_version['MINOR'],
+                            chrome_version['BUILD'], chrome_version['PATCH'])
+
+  @staticmethod
+  def _format_commit_hash(hash):
+    return 'g%s' % hash[:7]
+
+  # Computes old version numbers in the format "X.YYYY.A.gHHHHHHH".
+  #
+  # Where:
+  # - "X" is the CEF major version (currently 3).
+  # - "YYYY" is the Chromium branch.
+  # - "A" is an incremental number representing the number of commits in the
+  #   current branch. This is roughly equivalent to the SVN revision number but
+  #   on a per-branch basis and assists people in quickly determining the order
+  #   of builds in the same branch (for bug reports, etc).
+  # - "gHHHHHHH" is the 7-character abbreviation for the Git commit hash. This
+  #   facilitates lookup of the relevant commit history in Git.
+  #
+  # Example: "3.3729.1921.g62d140e"
+  def _compute_old_version(self):
+    if not self._old_version_string is None:
+      return
+
+    chrome_version = self.get_chrome_version_components()
+    cef_version = self.get_cef_version_components()
+    cef_commit = self.get_cef_commit_components()
+    cef_commit_hash = self._format_commit_hash(cef_commit['HASH'])
+
+    self._old_version_parts = {
+        'MAJOR': int(cef_version['CEF_MAJOR']),
+        'MINOR': int(chrome_version['BUILD']),
+        'PATCH': int(cef_commit['NUMBER'])
+    }
+    self._old_version_string = \
+        '%s.%s.%s.%s' % (cef_version['CEF_MAJOR'], chrome_version['BUILD'],
+                         cef_commit['NUMBER'], cef_commit_hash)
+
+  def _get_old_version_string(self):
+    self._compute_old_version()
+    return self._old_version_string
+
+  def _get_old_version_parts(self):
+    self._compute_old_version()
+    return self._old_version_parts
+
+  # Computes version numbers in the format:
+  # - "X.Y.Z+gHHHHHHH+chromium-A.B.C.D" for release branch builds.
+  # - "X.0.0-master.N+gHHHHHHH+chromium-A.B.C.D" for master branch builds.
+  #
+  # Where:
+  # - "X" is the Chromium major version (e.g. 74).
+  # - "Y" is an incremental number that starts at 0 when a release branch is
+  #   created and changes only when the CEF C/C++ API changes (similar to how
+  #   the CEF_API_HASH_UNIVERSAL value behaves in cef_version.h) (release branch
+  #   only).
+  # - "Z" is an incremental number that starts at 0 when a release branch is
+  #   created and changes on each commit, with reset to 0 when "Y" changes
+  #   (release branch only).
+  # - "N" is an incremental number representing the number of commits (master
+  #   branch only).
+  # - "gHHHHHHH" is the 7-character abbreviation for the Git commit hash. This
+  #   facilitates lookup of the relevant commit history in Git.
+  # - "A.B.C.D" is the Chromium version (e.g. 74.0.3729.6).
+  #
+  # Examples:
+  # - "74.0.1+g62d140e+chromium-74.0.3729.6" for a release build.
+  # - "74.0.0-master.1920+g725ed88+chromium-74.0.3729.0" for a master build.
+  def _compute_version(self):
+    if not self._version_string is None:
+      return
+
+    chrome_version = self.get_chrome_version_components()
+    chrome_major = chrome_version['MAJOR']
+    chrome_version_part = 'chromium-' + self.get_chromium_version_string()
+
+    cef_commit = self.get_cef_commit_components()
+    cef_commit_hash = self._format_commit_hash(cef_commit['HASH'])
+
+    # Remove the remote name prefix, if any.
+    cef_branch_name = git.get_branch_name(self.cef_path).split('/')[-1]
+
+    if cef_branch_name != chrome_version['BUILD']:
+      # Not on an official named release branch.
+      self._version_parts = {'MAJOR': int(chrome_major), 'MINOR': 0, 'PATCH': 0}
+      self._version_string = '%s.0.0-%s.%s+%s+%s' % \
+             (chrome_major, cef_branch_name, cef_commit['NUMBER'],
+              cef_commit_hash, chrome_version_part)
+    else:
+      cef_branch = self.get_cef_branch_version_components()
+
+      self._version_parts = {
+          'MAJOR': int(chrome_major),
+          'MINOR': cef_branch['MINOR'],
+          'PATCH': cef_branch['PATCH']
+      }
+      self._version_string = '%s.%d.%d+%s+%s' % \
+             (chrome_major, cef_branch['MINOR'], cef_branch['PATCH'],
+              cef_commit_hash, chrome_version_part)
+
+  def _get_version_string(self):
+    self._compute_version()
+    return self._version_string
+
+  def _get_version_parts(self):
+    self._compute_version()
+    return self._version_parts
+
+  def get_version_string(self, oldFormat=None):
+    """ Returns the CEF version number string based on current checkout state.
+    """
+    if oldFormat is None:
+      oldFormat = self._old_format_default
+
+    if oldFormat:
+      return self._get_old_version_string()
+    return self._get_version_string()
+
+  def get_version_parts(self, oldFormat=None):
+    """ Returns the CEF version number parts based on current checkout state.
+    """
+    if oldFormat is None:
+      oldFormat = self._old_format_default
+
+    if oldFormat:
+      return self._get_old_version_parts()
+    return self._get_version_parts()
+
+  def get_plist_version_string(self, oldFormat=None):
+    """ Returns the CEF version number string for plist files based on current
+        checkout state. """
+    parts = self.get_version_parts(oldFormat=oldFormat)
+    return "%d.%d.%d.0" % (parts['MAJOR'], parts['MINOR'], parts['PATCH'])
+
+  def get_dylib_version_string(self, oldFormat=None):
+    """ Returns the CEF version number string for dylib files based on current
+        checkout state. """
+    parts = self.get_version_parts(oldFormat=oldFormat)
+    # Dylib format supports a max value of 255 for the 2nd and 3rd components.
+    return "%d%d.%d.%d" % (parts['MAJOR'], parts['MINOR'], parts['PATCH'] / 255,
+                           parts['PATCH'] % 255)
+
+
+# Test the module.
+if __name__ == "__main__":
+  import sys
+
+  # Optionally specify a format.
+  formats = ['current', 'old', 'plist', 'dylib']
+  if len(sys.argv) >= 2:
+    formats = [sys.argv[1]]
+
+  # Optionally specify the path to chromium/src.
+  chromium_src_path = None
+  if len(sys.argv) >= 3:
+    chromium_src_path = sys.argv[2]
+
+  formatter = VersionFormatter(chromium_src_path)
+
+  for format in formats:
+    if len(formats) > 1:
+      print format
+
+    if format == 'old':
+      print formatter.get_version_string(True)
+    elif format == 'dylib':
+      print formatter.get_dylib_version_string()
+    elif format == 'plist':
+      print formatter.get_plist_version_string()
+    else:
+      print formatter.get_version_string(False)