Fix spelling

chrome/tools/build/mac/keystone_install.sh

 #!/bin/bash
 
 # Copyright (c) 2009 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.
 
 # Called by the Keystone system to update the installed application with a new
 # version from a disk image.
 
 # Return values:
 # 0  Happiness
 # 1  Unknown failure
 # 2  Basic sanity check destination failure (e.g. ticket points to nothing)
 # 3  Could not prepare existing installed version to receive update
 # 4  rsync failed (could not assure presence of Versions directory)
 # 5  rsync failed (could not copy new versioned directory to Versions)
 # 6  rsync failed (could not update outer .app bundle)
 # 7  Could not get the version, update URL, or channel after update
 # 8  Updated application does not have the version number from the update
 # 9  ksadmin failure
 # 10 Basic sanity check source failure (e.g. no app on disk image)
 
 set -e
 
 # Returns 0 (true) if the parameter exists, is a symbolic link, and appears
-# writeable on the basis of its POSIX permissions.  This is used to determine
+# writable on the basis of its POSIX permissions.  This is used to determine
 # writeability like test's -w primary, but -w resolves symbolic links and this
 # function does not.
-function is_writeable_symlink() {
+function is_writable_symlink() {
   SYMLINK=${1}
   LINKMODE=$(stat -f %Sp "${SYMLINK}" 2> /dev/null || true)
   if [ -z "${LINKMODE}" ] || [ "${LINKMODE:0:1}" != "l" ] ; then
     return 1
   fi
   LINKUSER=$(stat -f %u "${SYMLINK}" 2> /dev/null || true)
   LINKGROUP=$(stat -f %g "${SYMLINK}" 2> /dev/null || true)
   if [ -z "${LINKUSER}" ] || [ -z "${LINKGROUP}" ] ; then
     return 1
   fi
@@ skipping 22 matching lines @@
     return 1
   fi
 
   # Check the other-write bit.
   if [ "${LINKMODE:8:1}" = "w" ] ; then
     return 0
   fi
   return 1
 }
 
-# If SYMLINK exists and is a symbolic link, but is not writeable according to
-# is_writeable_symlink, this function attempts to replace it with a new
-# writeable symbolic link.  If FROM does not exist, is not a symbolic link, or
-# is already writeable, this function does nothing.  This function always
+# If SYMLINK exists and is a symbolic link, but is not writable according to
+# is_writable_symlink, this function attempts to replace it with a new
+# writable symbolic link.  If FROM does not exist, is not a symbolic link, or
+# is already writable, this function does nothing.  This function always
 # returns 0 (true).
-function ensure_writeable_symlink() {
+function ensure_writable_symlink() {
   SYMLINK=${1}
-  if [ -L "${SYMLINK}" ] && ! is_writeable_symlink "${SYMLINK}" ; then
+  if [ -L "${SYMLINK}" ] && ! is_writable_symlink "${SYMLINK}" ; then
     # If ${SYMLINK} refers to a directory, doing this naively might result in
     # the new link being placed in that directory, instead of replacing the
     # existing link.  ln -fhs is supposed to handle this case, but it does so
     # by unlinking (removing) the existing symbolic link before creating a new
     # one.  That leaves a small window during which the symbolic link is not
     # present on disk at all.
     #
     # To avoid that possibility, a new symbolic link is created in a temporary
     # location and then swapped into place with mv.  An extra temporary
     # directory is used to convince mv to replace the symbolic link: again, if
@@ skipping 114 matching lines @@
   IFS=$(printf '\n\t')
 
   # Only consider symbolic links in ${SRC}.  If there are any other links in
   # ${DEST} not present in ${SRC}, rsync will delete them as needed later.
   LINKS=$(cd "${SRC}" && find . -type l)
 
   for link in ${LINKS} ; do
     # ${link} is relative to ${SRC}.  Prepending ${DEST} looks for the same
     # link already on disk.
     DESTLINK="${DEST}/${link}"
-    ensure_writeable_symlink "${DESTLINK}"
+    ensure_writable_symlink "${DESTLINK}"
   done
 
   # Go back to how things were.
   IFS="${IFS_OLD}"
   set -e
 fi
 
 # 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
@@ skipping 182 matching lines @@
         grep -Fqx "${PS_STRING}") &&
      (! lsof "${LSOF_FILE}" >& /dev/null) ; then
     # It doesn't look like anything is using this versioned directory.  Get rid
     # of it.
     rm -rf "${versioned_dir}"
   fi
 done
 
 # If this script is not running as root (indicating an update driven by a user
 # Keystone ticket) and the application is installed somewhere under
-# /Applications, try to make it writeable by all admin users.  This will allow
+# /Applications, try to make it writable by all admin users.  This will allow
 # other admin users to update the application from their own user Keystone
 # instances.
 #
 # If the script is not running as root and the application is not installed
 # under /Applications, it might not be in a system-wide location, and it
 # probably won't be something that other users on the system are running, so
-# err on the side of safety and don't make it group-writeable.
+# err on the side of safety and don't make it group-writable.
 #
 # If this script is running as root, it's driven by a system Keystone ticket,
 # and future updates can be expected to be applied the same way, so
 # admin-writeability is not a concern.  Set the entire thing to be owned by
 # root in that case, regardless of where it's installed, and drop any group
 # and other write permission.
 #
 # If this script is running as a user that is not a member of the admin group,
 # the chgrp operation will not succeed.  Tolerate that case, because it's
 # better than the alternative, which is to make the application
-# world-writeable.
+# world-writable.
 CHMOD_MODE="a+rX,u+w,go-w"
 if [ ${EUID} -ne 0 ] ; then
   if [ "${DEST:0:14}" = "/Applications/" ] &&
      chgrp -Rh admin "${DEST}" >& /dev/null ; then
     CHMOD_MODE="a+rX,ug+w,o-w"
   fi
 else
   chown -Rh root:wheel "${DEST}" >& /dev/null
 fi
 
@@ skipping 28 matching lines @@
    ([ ${OS_MAJOR} -eq 10 ] && [ ${OS_MINOR} -ge 6 ]) ; then
   # On 10.6, xattr supports -r for recursive operation.
   xattr -d -r "${QUARANTINE_ATTR}" "${DEST}" >& /dev/null
 else
   # On earlier systems, xattr doesn't support -r, so run xattr via find.
   find "${DEST}" -exec xattr -d "${QUARANTINE_ATTR}" {} + >& /dev/null
 fi
 
 # Great success!
 exit 0