Make version comparisons in keystone_install.sh more generic

chrome/installer/mac/keystone_install.sh

 #!/bin/bash -p
 
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # usage: keystone_install.sh update_dmg_mount_point
 #
 # Called by the Keystone system to update the installed application with a new
 # version from a disk image.
@@ skipping 261 matching lines @@
   while IFS= read -r -d $'\0' symlink; do
     ensure_writable_symlink "${symlink}"
   done < <(find "${directory}" -type l -print0)
 
   # Go back to how things were.
   if [[ -n "${set_e}" ]]; then
     set -e
   fi
 }
 
+# is_version_ge accepts two version numbers, left and right, and performs a
+# piecewise comparison determining the result of left >= right, returning true
+# (0) if left >= right, and false (1) if left < right. If left or right are
+# missing components relative to the other, the missing components are assumed
+# to be 0, such that 10.6 == 10.6.0.
+is_version_ge() {
+  local left="${1}"
+  local right="${2}"
+
+  local -a left_array right_array
+  IFS=. left_array=(${left})
+  IFS=. right_array=(${right})
+
+  local left_count=${#left_array[@]}
+  local right_count=${#right_array[@]}
+  local count=${left_count}
+  if [[ ${right_count} -lt ${count} ]]; then
+    count=${right_count}
+  fi
+
+  # Compare the components piecewise, as long as there are corresponding
+  # components on each side. If left_element and right_element are unequal,
+  # a comparison can be made.
+  local index=0
+  while [[ ${index} -lt ${count} ]]; do
+    local left_element="${left_array[${index}]}"
+    local right_element="${right_array[${index}]}"
+    if [[ ${left_element} -gt ${right_element} ]]; then
+      return 0
+    elif [[ ${left_element} -lt ${right_element} ]]; then
+      return 1
+    fi
+    ((++index))
+  done
+
+  # If there are more components on the left than on the right, continue
+  # comparing, assuming 0 for each of the missing components on the right.
+  while [[ ${index} -lt ${left_count} ]]; do
+    local left_element="${left_array[${index}]}"
+    if [[ ${left_element} -gt 0 ]]; then
+      return 0
+    fi
+    ((++index))
+  done
+
+  # If there are more components on the right than on the left, continue
+  # comparing, assuming 0 for each of the missing components on the left.
+  while [[ ${index} -lt ${right_count} ]]; do
+    local right_element="${right_array[${index}]}"
+    if [[ ${right_element} -gt 0 ]]; then
+      return 1
+    fi
+    ((++index))
+  done
+
+  # Upon reaching this point, the two version numbers are semantically equal.
+  return 0
+}
+
+# Prints the OS version, as reported by sw_vers -productVersion, to stdout.
+# This function operates with "static" variables: it will only check the OS
+# version once per script run.
+g_checked_os_version=
+g_os_version=
+os_version() {
+  if [[ -z "${g_checked_os_version}" ]]; then
+    g_checked_os_version="y"
+    g_os_version="$(sw_vers -productVersion)"
+    note "g_os_version = ${g_os_version}"
+  fi
+  echo "${g_os_version}"
+  return 0
+}
+
+# Compares the running OS version against a supplied version number,
+# |check_version|, and returns 0 (true) if the running OS version is greater
+# than or equal to |check_version| according to a piece-wise comparison.
+# Returns 1 (false) if the running OS version number cannot be determined or
+# if |check_version| is greater than the running OS version. |check_version|
+# should be a string of the form "major.minor" or "major.minor.micro".
+is_os_version_ge() {
+  local check_version="${1}"
+
+  local os_version="$(os_version)"
+  is_version_ge "${os_version}" "${check_version}"
+
+  # The return value of is_version_ge is used as this function's return value.
+}
+
+# Returns 0 (true) if xattr supports -r for recursive operation.
+os_xattr_supports_r() {
+  # xattr -r is supported in Mac OS X 10.6.
+  is_os_version_ge 10.6
+
+  # The return value of is_os_version_ge is used as this function's return
+  # value.
+}
+
 # Prints the version of ksadmin, as reported by ksadmin --ksadmin-version, to
 # stdout.  This function operates with "static" variables: it will only check
 # the ksadmin version once per script run.  If ksadmin is old enough to not
 # support --ksadmin-version, or another error occurs, this function prints an
 # empty string.
 g_checked_ksadmin_version=
 g_ksadmin_version=
 ksadmin_version() {
   if [[ -z "${g_checked_ksadmin_version}" ]]; then
     g_checked_ksadmin_version="y"
     g_ksadmin_version="$(ksadmin --ksadmin-version || true)"
+    note "g_ksadmin_version = ${g_ksadmin_version}"
   fi
   echo "${g_ksadmin_version}"
   return 0
 }
 
 # Compares the installed ksadmin version against a supplied version number,
 # |check_version|, and returns 0 (true) if the installed Keystone version is
 # greater than or equal to |check_version| according to a piece-wise
 # comparison.  Returns 1 (false) if the installed Keystone version number
 # cannot be determined or if |check_version| is greater than the installed
 # Keystone version.  |check_version| should be a string of the form
-# "major.minor.micro.build".  Returns 1 (false) if either |check_version| or
-# the Keystone version do not match this format.
-readonly KSADMIN_VERSION_RE="^([0-9]+)\\.([0-9]+)\\.([0-9]+)\\.([0-9]+)\$"
+# "major.minor.micro.build".
 is_ksadmin_version_ge() {
   local check_version="${1}"
 
-  if ! [[ "${check_version}" =~ ${KSADMIN_VERSION_RE} ]]; then
-    return 1
-  fi
+  local ksadmin_version="$(ksadmin_version)"
+  is_version_ge "${ksadmin_version}" "${check_version}"
 
-  local check_components=("${BASH_REMATCH[1]}"
-                          "${BASH_REMATCH[2]}"
-                          "${BASH_REMATCH[3]}"
-                          "${BASH_REMATCH[4]}")
-
-  local ksadmin_version
-  ksadmin_version="$(ksadmin_version)"
-
-  if ! [[ "${ksadmin_version}" =~ ${KSADMIN_VERSION_RE} ]]; then
-    return 1
-  fi
-
-  local ksadmin_components=("${BASH_REMATCH[1]}"
-                            "${BASH_REMATCH[2]}"
-                            "${BASH_REMATCH[3]}"
-                            "${BASH_REMATCH[4]}")
-
-  local i
-  for i in "${!check_components[@]}"; do
-    local check_component="${check_components[${i}]}"
-    local ksadmin_component="${ksadmin_components[${i}]}"
-
-    if [[ ${ksadmin_component} -lt ${check_component} ]]; then
-      # ksadmin_version is less than check_version.
-      return 1
-    fi
-    if [[ ${ksadmin_component} -gt ${check_component} ]]; then
-      # ksadmin_version is greater than check_version.
-      return 0
-    fi
-  done
-
-  # The version numbers are equal.
-  return 0
+  # The return value of is_version_ge is used as this function's return value.
 }
 
 # Returns 0 (true) if ksadmin supports --tag.
 ksadmin_supports_tag() {
   local ksadmin_version
 
   ksadmin_version="$(ksadmin_version)"
   if [[ -n "${ksadmin_version}" ]]; then
     # A ksadmin that recognizes --ksadmin-version and provides a version
     # number is new enough to recognize --tag.
@@ skipping 898 matching lines @@
 
   note "chmod_mode = ${chmod_mode}"
   chmod -R "${chmod_mode}" "${installed_app}" 2> /dev/null
 
   # On the Mac, or at least on HFS+, symbolic link permissions are significant,
   # but chmod -R and -h can't be used together.  Do another pass to fix the
   # permissions on any symbolic links.
   find "${installed_app}" -type l -exec chmod -h "${chmod_mode}" {} + \
       2> /dev/null
 
-  # Host OS version check, to be able to take advantage of features on newer
-  # systems and fall back to slow ways of doing things on older systems.
-  local os_version
-  os_version="$(sw_vers -productVersion)"
-  note "os_version = ${os_version}"
-
-  local os_major=0
-  local os_minor=0
-  if [[ "${os_version}" =~ ^([0-9]+)\.([0-9]+) ]]; then
-    os_major="${BASH_REMATCH[1]}"
-    os_minor="${BASH_REMATCH[2]}"
-  fi
-  note "os_major = ${os_major}"
-  note "os_minor = ${os_minor}"
-
   # If an update is triggered from within the application itself, the update
   # process inherits the quarantine bit (LSFileQuarantineEnabled).  Any files
   # or directories created during the update will be quarantined in that case,
   # which may cause Launch Services to display quarantine UI.  That's bad,
   # especially if it happens when the outer .app launches a quarantined inner
   # helper.  If the application is already on the system and is being updated,
   # then it can be assumed that it should not be quarantined.  Use xattr to
   # drop the quarantine attribute.
   #
   # TODO(mark): Instead of letting the quarantine attribute be set and then
   # dropping it here, figure out a way to get the update process to run
   # without LSFileQuarantineEnabled even when triggering an update from within
   # the application.
   note "lifting quarantine"
 
-  if [[ ${os_major} -gt 10 ]] ||
-     ([[ ${os_major} -eq 10 ]] && [[ ${os_minor} -ge 6 ]]); then
+  if os_xattr_supports_r; then
     # On 10.6, xattr supports -r for recursive operation.
     xattr -d -r "${QUARANTINE_ATTR}" "${installed_app}" 2> /dev/null
   else
     # On earlier systems, xattr doesn't support -r, so run xattr via find.
     find "${installed_app}" -exec xattr -d "${QUARANTINE_ATTR}" {} + \
         2> /dev/null
   fi
 
   # Do Keychain reauthorization. This involves running a stub executable on
   # the dmg that loads the newly-updated framework and jumps to it to perform
@@ skipping 50 matching lines @@
 
 # Check "less than" instead of "not equal to" in case Keystone ever changes to
 # pass more arguments.
 if [[ ${#} -lt 1 ]]; then
   usage
   exit 2
 fi
 
 main "${@}"
 exit ${?}