Roll reference builds to 35.0.1916.114.

chrome_mac/Google Chrome Packaging/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 702 matching lines @@
   readonly UNROOTED_DEBUG_FILE="Library/Google/Google Chrome Updater Debug"
 
   readonly APP_VERSION_KEY="CFBundleShortVersionString"
   readonly APP_BUNDLEID_KEY="CFBundleIdentifier"
   readonly KS_VERSION_KEY="KSVersion"
   readonly KS_PRODUCT_KEY="KSProductID"
   readonly KS_URL_KEY="KSUpdateURL"
   readonly KS_BRAND_KEY="KSBrandID"
 
   readonly QUARANTINE_ATTR="com.apple.quarantine"
-  readonly KEYCHAIN_REAUTHORIZE_DIR=".keychain_reauthorize"
 
   # Don't use rsync -a, because -a expands to -rlptgoD.  -g and -o copy owners
   # and groups, respectively, from the source, and that is undesirable in this
   # case.  -D copies devices and special files; copying devices only works
   # when running as root, so for consistency between privileged and
   # unprivileged operation, this option is omitted as well.
   #  -I, --ignore-times  don't skip files that match in size and mod-time
   #  -l, --links         copy symlinks as symlinks
   #  -r, --recursive     recurse into directories
   #  -p, --perms         preserve permissions
@@ skipping 294 matching lines @@
   # Collect the installed application's brand code, it will be used later.  It
   # is not an error for the installed application to not have a brand code.
   local old_ks_plist="${installed_app_plist}"
   note "old_ks_plist = ${old_ks_plist}"
   local old_brand
   old_brand="$(infoplist_read "${old_ks_plist}" \
                               "${KS_BRAND_KEY}" 2> /dev/null ||
                true)"
   note "old_brand = ${old_brand}"
 
+  local update_versioned_dir=
+  if [[ -z "${is_patch}" ]]; then
+    update_versioned_dir="${update_app}/${VERSIONS_DIR}/${update_version_app}"
+    note "update_versioned_dir = ${update_versioned_dir}"
+  fi
+
   if has_32_bit_only_cpu; then
     # On a 32-bit-only system, make sure that the update contains 32-bit code.
     note "system is 32-bit-only"
 
     local test_binary
     if [[ -z "${is_patch}" ]]; then
       # For a full installer, the framework is available, so check it for
       # 32-bit code.
-      local old_framework_dir="${old_versioned_dir}/${FRAMEWORK_DIR}"
-      test_binary="${old_framework_dir}/${FRAMEWORK_NAME}"
+      local update_framework_dir="${update_versioned_dir}/${FRAMEWORK_DIR}"
+      test_binary="${update_framework_dir}/${FRAMEWORK_NAME}"
     else
       # No application code is guaranteed to be available at this point for a
       # patch updater, but goobspatch is built alongside and will have the
       # same bitness of the product that this updater will install, so it's a
       # reasonable proxy.
       test_binary="${patch_dir}/goobspatch"
     fi
     note "test_binary = ${test_binary}"
 
     if ! file "${test_binary}" | grep -q 'i386$'; then
@@ skipping 39 matching lines @@
   # of the versioned directory, so toss out whatever's there.  Don't treat
   # this as a critical step: if removal fails, operation can still proceed to
   # to the dirpatcher or rsync, which will likely fail.
   if [[ -e "${new_versioned_dir}" ]] &&
      ([[ -L "${new_versioned_dir}" ]] ||
       ! [[ -d "${new_versioned_dir}" ]]); then
     note "removing non-directory in place of versioned directory"
     rm -f "${new_versioned_dir}" 2> /dev/null || true
   fi
 
-  local update_versioned_dir
-  if [[ -z "${is_patch}" ]]; then
-    update_versioned_dir="${update_app}/${VERSIONS_DIR}/${update_version_app}"
-    note "update_versioned_dir = ${update_versioned_dir}"
-  else  # [[ -n "${is_patch}" ]]
+  if [[ -n "${is_patch}" ]]; then
     # dirpatcher won't patch into a directory that already exists.  Doing so
     # would be a bad idea, anyway.  If ${new_versioned_dir} already exists,
     # it may be something left over from a previous failed or incomplete
     # update attempt, or it may be the live versioned directory if this is a
     # same-version update intended only to change channels.  Since there's no
     # way to tell, this case is handled by having dirpatcher produce the new
     # versioned directory in a temporary location and then having rsync copy
     # it into place as an ${update_versioned_dir}, the same as in a non-patch
     # update.  If ${new_versioned_dir} doesn't exist, dirpatcher can place the
     # new versioned directory at that location directly.
@@ skipping 479 matching lines @@
 
   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
-  # the reauthorization. The stub executable can be signed by the old
-  # certificate even after the rest of Chrome switches to the new certificate,
-  # so it still has access to the old Keychain items. The stub executable is
-  # an unbundled flat file executable whose name matches the real
-  # application's bundle identifier, so it's permitted access to the Keychain
-  # items. Doing a reauthorization step at update time reauthorizes Keychain
-  # items for users who never bother restarting Chrome, and provides a
-  # mechanism to continue doing reauthorizations even after the certificate
-  # changes. However, it only works for non-system ticket installations of
-  # Chrome, because the updater runs as root when on a system ticket, and root
-  # can't access individual user Keychains.
-  #
-  # Even if the reauthorization tool is launched, it doesn't necessarily try
-  # to do anything. It will only attempt to perform a reauthorization if one
-  # hasn't yet been done at update time.
-  note "maybe reauthorizing Keychain"
-
-  if [[ -z "${system_ticket}" ]]; then
-    local new_bundleid_app
-    new_bundleid_app="$(infoplist_read "${installed_app_plist}" \
-                                       "${APP_BUNDLEID_KEY}" || true)"
-    note "new_bundleid_app = ${new_bundleid_app}"
-
-    local keychain_reauthorize_dir="\
-${update_dmg_mount_point}/${KEYCHAIN_REAUTHORIZE_DIR}"
-    local keychain_reauthorize_path="\
-${keychain_reauthorize_dir}/${new_bundleid_app}"
-    note "keychain_reauthorize_path = ${keychain_reauthorize_path}"
-
-    if [[ -x "${keychain_reauthorize_path}" ]]; then
-      local framework_dir="${new_versioned_dir}/${FRAMEWORK_DIR}"
-      local framework_code_path="${framework_dir}/${FRAMEWORK_NAME}"
-      note "framework_code_path = ${framework_code_path}"
-
-      if [[ -f "${framework_code_path}" ]]; then
-        note "reauthorizing Keychain"
-        "${keychain_reauthorize_path}" "${framework_code_path}"
-      fi
-    fi
-  else
-    note "system ticket, not reauthorizing Keychain"
-  fi
-
   # Great success!
   note "done!"
 
   trap - EXIT
 
   return 0
 }
 
 # 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 ${?}