Typo police.

chrome/installer/mac/keystone_install.sh

 #!/bin/bash -p
 
-# Copyright (c) 2009 The Chromium Authors. All rights reserved.
+# Copyright (c) 2011 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.
 #
 # Environment variables:
 # GOOGLE_CHROME_UPDATER_DEBUG
@@ skipping 206 matching lines @@
     (ln -fhs "${target}" "${temp_link}" && \
         chmod -h 755 "${temp_link}" && \
         mv -f "${temp_link}" "${symlink_dir}/") || true
     rm -rf "${temp_link_dir}"
   fi
 
   return 0
 }
 
 # ensure_writable_symlinks_recursive calls ensure_writable_symlink for every
-# symbolic link in |directory|, recursivley.
+# symbolic link in |directory|, recursively.
 #
 # In some very weird and rare cases, it is possible to wind up with a user
 # installation that contains symbolic links that the user does not have write
 # permission over.  More on how that might happen later.
 #
 # If a weird and rare case like this is observed, rsync will exit with an
 # error when attempting to update the times on these symbolic links.  rsync
 # may not be intelligent enough to try creating a new symbolic link in these
 # cases, but this script can be.
 #
 # The problem occurs when an administrative user first drag-installs the
 # application to /Applications, resulting in the program's user being set to
 # the user's own ID.  If, subsequently, a .pkg package is installed over that,
 # the existing directory ownership will be preserved, but file ownership will
-# be changed to whateer is specified by the package, typically root.  This
+# be changed to whatever is specified by the package, typically root.  This
 # applies to symbolic links as well.  On a subsequent update, rsync will be
 # able to copy the new files into place, because the user still has permission
 # to write to the directories.  If the symbolic link targets are not changing,
 # though, rsync will not replace them, and they will remain owned by root.
 # The user will not have permission to update the time on the symbolic links,
 # resulting in an rsync error.
 ensure_writable_symlinks_recursive() {
   local directory="${1}"
 
   # This fix-up is not necessary when running as root, because root will
@@ skipping 409 matching lines @@
   note "installed_app_plist_path = ${installed_app_plist_path}"
   local old_version_app
   old_version_app="$(defaults read "${installed_app_plist}" \
                                    "${APP_VERSION_KEY}" || true)"
   note "old_version_app = ${old_version_app}"
 
   # old_version_app is not required, because it won't be present in skeleton
   # bootstrap installations, which just have an empty .app directory.  Only
   # require it when doing a patch update, and use it to validate that the
   # patch applies to the old installed version.  By definition, skeleton
-  # bootstraps can't be installed with patch udpates.  They require the full
+  # bootstraps can't be installed with patch updates.  They require the full
   # application on the disk image.
   if [[ -n "${is_patch}" ]]; then
     if [[ -z "${old_version_app}" ]]; then
       err "old_version_app required for patch"
       exit 6
     elif [[ "${old_version_app}" != "${update_version_app_old}" ]]; then
       err "this patch does not apply to the installed version"
       exit 6
     fi
   fi
@@ skipping 21 matching lines @@
 
   ensure_writable_symlinks_recursive "${installed_app}"
 
   # By copying to ${installed_app}, the existing application name will be
   # preserved, if the user has renamed the application on disk.  Respecting
   # the user's changes is friendly.
 
   # Make sure that ${installed_versions_dir} exists, so that it can receive
   # the versioned directory.  It may not exist if updating from an older
   # version that did not use the versioned layout on disk.  Later, during the
-  # rsync to copy the applciation directory, the mode bits and timestamp on
+  # rsync to copy the application directory, the mode bits and timestamp on
   # ${installed_versions_dir} will be set to conform to whatever is present in
   # the update.
   #
   # ${installed_app} is guaranteed to exist at this point, but
   # ${installed_app}/${CONTENTS_DIR} may not if things are severely broken or
   # if this update is actually an initial installation from a Keystone
   # skeleton bootstrap.  The mkdir creates ${installed_app}/${CONTENTS_DIR} if
   # it doesn't exist; its mode bits will be fixed up in a subsequent rsync.
   note "creating installed_versions_dir"
   if ! mkdir -p "${installed_versions_dir}"; then
@@ skipping 325 matching lines @@
   # (obviously) and the version that was just replaced, and to use ps and lsof
   # to see if it looks like any processes are currently using any other old
   # directories.  Directories not in use are removed.  Old versioned
   # directories that are in use are left alone so as to not interfere with
   # running processes.  These directories can be cleaned up by this script on
   # future updates.
   #
   # To determine which directories are in use, both ps and lsof are used.
   # Each approach has limitations.
   #
-  # The ps check looks for processes within the verisoned directory.  Only
+  # The ps check looks for processes within the versioned directory.  Only
   # helper processes, such as renderers, are within the versioned directory.
   # Browser processes are not, so the ps check will not find them, and will
   # assume that a versioned directory is not in use if a browser is open
   # without any windows.  The ps mechanism can also only detect processes
   # running on the system that is performing the update.  If network shares
   # are involved, all bets are off.
   #
   # The lsof check looks to see what processes have the framework dylib open.
   # Browser processes will have their versioned framework dylib open, so this
   # check is able to catch browsers even if there are no associated helper
   # processes.  Like the ps check, the lsof check is limited to processes on
   # the system that is performing the update.  Finally, unless running as
   # root, the lsof check can only find processes running as the effective user
   # performing the update.
   #
-  # These limitations are motiviations to additionally preserve the versioned
+  # These limitations are motivations to additionally preserve the versioned
   # directory corresponding to the version that was just replaced.
   note "cleaning up old versioned directories"
 
   local versioned_dir
   for versioned_dir in "${installed_versions_dir}/"*; do
     note "versioned_dir = ${versioned_dir}"
     if [[ "${versioned_dir}" = "${new_versioned_dir}" ]] || \
        [[ "${versioned_dir}" = "${old_versioned_dir}" ]]; then
       # This is the versioned directory corresponding to the update that was
       # just applied or the version that was previously in use.  Leave it
@@ skipping 134 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 ${?}