libv8 4.5.95.5 → 5.0.71.48.0beta2

data/vendor/depot_tools/trychange.py

@@ -26,8 +26,6 @@ import urllib
 import urllib2
 import urlparse
 
-import breakpad  # pylint: disable=W0611
-
 import fix_encoding
 import gcl
 import gclient_utils

data/vendor/depot_tools/update_depot_tools

@@ -11,7 +11,21 @@ then
   exit
 fi
 
-# Test if this script is running under a MSys install.  If it is, we will
+# Test if this script is running under a MSYS install. This is likely an error
+# if it is, so we warn the user accordingly.
+OUTPUT="$(uname | grep 'MSYS')"
+MSYS=$?
+if [ $MSYS = 0 ]; then
+  echo 'WARNING: It looks like you are running these tools from an MSYS shell'
+  echo '(as opposed to a MinGW shell). This shell is not supported and may'
+  echo 'fail in mysterious ways.'
+  echo
+  echo 'To run the supported MinGW shell, use `git bash`, or use `bin/bash.exe`'
+  echo 'in your MinGW installation, as opposed to `usr/bin/bash.exe`.'
+  echo
+fi
+
+# Test if this script is running under a MinGW install.  If it is, we will
 # hardcode the paths to SVN and Git where possible.
 OUTPUT="$(uname | grep 'MINGW')"
 MINGW=$?
@@ -25,11 +39,19 @@ else
   fi
 fi
 
-# Don't try to use Cygwin tools.  Get real win32 tools using the batch script.
-OUTPUT="$(uname | grep 'CYGWIN')"
-CYGWIN=$?
-if [ $CYGWIN = 0 ]; then
-  cmd /c `cygpath -w "$base_dir/bootstrap/win/win_tools.bat"`
+# We want to update the bundled tools even under MinGW.
+if [ $MINGW = 0 ]; then
+  $COMSPEC /c `cygpath -w "$base_dir/bootstrap/win/win_tools.bat"`
+  case $? in
+    123)
+      # msys environment was upgraded, need to quit.
+      exit 123
+      ;;
+    0)
+      ;;
+    *)
+      exit $?
+  esac
 fi
 
 CANONICAL_GIT_URL="https://chromium.googlesource.com/chromium/tools/depot_tools.git"
@@ -152,8 +174,4 @@ then
   fi
 fi
 
-find "$base_dir" -iname "*.pyc" -exec rm {} \;
-
-# Initialize/update virtualenv.
-cd $base_dir
-python -u ./bootstrap/bootstrap.py --deps_file bootstrap/deps.pyl --quiet ENV
+find "$base_dir" -iname "*.pyc" -exec rm -f {} \;

data/vendor/depot_tools/update_depot_tools.bat

@@ -10,13 +10,13 @@ setlocal
 :: Windows freaks out if a file is overwritten while it's being executed.  Copy
 :: this script off to a temporary location and reinvoke from there before
 :: running any svn or git commands.
-IF %~nx0==update_depot_tools.bat (
-  COPY /Y %~dp0update_depot_tools.bat %TEMP%\update_depot_tools_tmp.bat >nul
+IF "%~nx0"=="update_depot_tools.bat" (
+  COPY /Y "%~dp0update_depot_tools.bat" "%TEMP%\update_depot_tools_tmp.bat" >nul
   if errorlevel 1 goto :EOF
-  %TEMP%\update_depot_tools_tmp.bat %~dp0 %*
+  "%TEMP%\update_depot_tools_tmp.bat" "%~dp0" %*
 )
 
-set DEPOT_TOOLS_DIR=%1
+set DEPOT_TOOLS_DIR=%~1
 SHIFT
 
 set GIT_URL=https://chromium.googlesource.com/chromium/tools/depot_tools.git
@@ -27,11 +27,6 @@ if errorlevel 1 goto :EOF
 :: Now clear errorlevel so it can be set by other programs later.
 set errorlevel=
 
-:: Initialize/update virtualenv.
-cd /d "%DEPOT_TOOLS_DIR%."
-python -u bootstrap\bootstrap.py --deps_file bootstrap\deps.pyl --quiet ENV
-if errorlevel 1 goto :EOF
-
 :: Shall skip automatic update?
 IF "%DEPOT_TOOLS_UPDATE%" == "0" GOTO :EOF
 

data/vendor/depot_tools/upload_to_google_storage.py

@@ -12,6 +12,7 @@ import Queue
 import re
 import stat
 import sys
+import tarfile
 import threading
 import time
 
@@ -75,7 +76,7 @@ def _upload_worker(
     file_url = '%s/%s' % (base_url, sha1_sum)
     if gsutil.check_call('ls', file_url)[0] == 0 and not force:
       # File exists, check MD5 hash.
-      _, out, _ = gsutil.check_call('ls', '-L', file_url)
+      _, out, _ = gsutil.check_call_with_retries('ls', '-L', file_url)
       etag_match = re.search('ETag:\s+([a-z0-9]{32})', out)
       if etag_match:
         remote_md5 = etag_match.group(1)
@@ -96,7 +97,7 @@ def _upload_worker(
     if gzip:
       gsutil_args.extend(['-z', gzip])
     gsutil_args.extend([filename, file_url])
-    code, _, err = gsutil.check_call(*gsutil_args)
+    code, _, err = gsutil.check_call_with_retries(*gsutil_args)
     if code != 0:
       ret_codes.put(
           (code,
@@ -108,9 +109,9 @@ def _upload_worker(
     # the download script will check for to preserve the executable bit.
     if not sys.platform.startswith('win'):
       if os.stat(filename).st_mode & stat.S_IEXEC:
-        code, _, err = gsutil.check_call('setmeta', '-h',
-                                         'x-goog-meta-executable:1', file_url)
-        if code:
+        code, _, err = gsutil.check_call_with_retries(
+            'setmeta', '-h', 'x-goog-meta-executable:1', file_url)
+        if not code:
           ret_codes.put(
               (code,
                'Encountered error on setting metadata on %s\n%s' %
@@ -207,11 +208,38 @@ def upload_to_google_storage(
   return max_ret_code
 
 
+def create_archives(dirs):
+  archive_names = []
+  for name in dirs:
+    tarname = '%s.tar.gz' % name
+    with tarfile.open(tarname, 'w:gz') as tar:
+      tar.add(name)
+    archive_names.append(tarname)
+  return archive_names
+
+
+def validate_archive_dirs(dirs):
+  # We don't allow .. in paths in our archives.
+  if any(map(lambda x: '..' in x, dirs)):
+    return False
+  # We only allow dirs.
+  if any(map(lambda x: not os.path.isdir(x), dirs)):
+    return False
+  # We don't allow sym links in our archives.
+  if any(map(os.path.islink, dirs)):
+    return False
+  # We required that the subdirectories we are archiving are all just below
+  # cwd.
+  return not any(map(lambda x: x not in next(os.walk('.'))[1], dirs))
+
+
 def main():
   parser = optparse.OptionParser(USAGE_STRING)
   parser.add_option('-b', '--bucket',
                     help='Google Storage bucket to upload to.')
   parser.add_option('-e', '--boto', help='Specify a custom boto file.')
+  parser.add_option('-a', '--archive', action='store_true',
+                    help='Archive directory as a tar.gz file')
   parser.add_option('-f', '--force', action='store_true',
                     help='Force upload even if remote file exists.')
   parser.add_option('-g', '--gsutil_path', default=GSUTIL_DEFAULT_PATH,
@@ -235,6 +263,15 @@ def main():
   # Enumerate our inputs.
   input_filenames = get_targets(args, parser, options.use_null_terminator)
 
+  if options.archive:
+    if not validate_archive_dirs(input_filenames):
+      parser.error('Only directories just below cwd are valid entries when '
+                   'using the --archive argument. Entries can not contain .. '
+                   ' and entries can not be symlinks. Entries was %s' %
+                    input_filenames)
+      return 1
+    input_filenames = create_archives(input_filenames)
+
   # Make sure we can find a working instance of gsutil.
   if os.path.exists(GSUTIL_DEFAULT_PATH):
     gsutil = Gsutil(GSUTIL_DEFAULT_PATH, boto_path=options.boto)

data/vendor/depot_tools/win_toolchain/OWNERS

@@ -1 +1,2 @@
+brucedawson@chromium.org
 scottmg@chromium.org

data/vendor/depot_tools/win_toolchain/get_toolchain_if_necessary.py

@@ -30,6 +30,7 @@ import hashlib
 import json
 import optparse
 import os
+import platform
 import shutil
 import subprocess
 import sys
@@ -37,6 +38,23 @@ import tempfile
 import time
 import zipfile
 
+# winreg isn't natively available under CygWin
+if sys.platform == "win32":
+  try:
+    import winreg
+  except ImportError:
+    import _winreg as winreg
+elif sys.platform == "cygwin":
+  try:
+    import cygwinreg as winreg
+  except ImportError:
+    print ''
+    print 'CygWin does not natively support winreg but a replacement exists.'
+    print 'https://pypi.python.org/pypi/cygwinreg/'
+    print ''
+    print 'Try: easy_install cygwinreg'
+    print ''
+    raise
 
 BASEDIR = os.path.dirname(os.path.abspath(__file__))
 DEPOT_TOOLS_PATH = os.path.join(BASEDIR, '..')
@@ -56,23 +74,32 @@ def GetFileList(root):
   file_list = []
   for base, _, files in os.walk(root):
     paths = [os.path.join(base, f) for f in files]
-    file_list.extend(x.lower() for x in paths)
-  return sorted(file_list)
+    # Ignore WER ReportQueue entries that vctip/cl leave in the bin dir if/when
+    # they crash.
+    file_list.extend(x.lower() for x in paths if 'WER\\ReportQueue' not in x)
+  return sorted(file_list, key=lambda s: s.replace('/', '\\'))
 
 
-def MakeTimestampsFileName(root):
-  return os.path.join(root, '..', '.timestamps')
+def MakeTimestampsFileName(root, sha1):
+  return os.path.join(root, os.pardir, '%s.timestamps' % sha1)
 
 
-def CalculateHash(root):
+def CalculateHash(root, expected_hash):
   """Calculates the sha1 of the paths to all files in the given |root| and the
-  contents of those files, and returns as a hex string."""
-  file_list = GetFileList(root)
+  contents of those files, and returns as a hex string.
 
-  # Check whether we previously saved timestamps in $root/../.timestamps. If
-  # we didn't, or they don't match, then do the full calculation, otherwise
+  |expected_hash| is the expected hash value for this toolchain if it has
+  already been installed.
+  """
+  if expected_hash:
+    full_root_path = os.path.join(root, expected_hash)
+  else:
+    full_root_path = root
+  file_list = GetFileList(full_root_path)
+  # Check whether we previously saved timestamps in $root/../{sha1}.timestamps.
+  # If we didn't, or they don't match, then do the full calculation, otherwise
   # return the saved value.
-  timestamps_file = MakeTimestampsFileName(root)
+  timestamps_file = MakeTimestampsFileName(root, expected_hash)
   timestamps_data = {'files': [], 'sha1': ''}
   if os.path.exists(timestamps_file):
     with open(timestamps_file, 'rb') as f:
@@ -83,31 +110,53 @@ def CalculateHash(root):
         pass
 
   matches = len(file_list) == len(timestamps_data['files'])
+  # Don't check the timestamp of the version file as we touch this file to
+  # indicates which versions of the toolchain are still being used.
+  vc_dir = os.path.join(full_root_path, 'VC').lower()
   if matches:
     for disk, cached in zip(file_list, timestamps_data['files']):
-      if disk != cached[0] or os.stat(disk).st_mtime != cached[1]:
+      if disk != cached[0] or (
+          disk != vc_dir and os.path.getmtime(disk) != cached[1]):
         matches = False
         break
   if matches:
     return timestamps_data['sha1']
 
+  # Make long hangs when updating the toolchain less mysterious.
+  print 'Calculating hash of toolchain in %s. Please wait...' % full_root_path
+  sys.stdout.flush()
   digest = hashlib.sha1()
   for path in file_list:
-    digest.update(path)
+    path_without_hash = str(path).replace('/', '\\')
+    if expected_hash:
+      path_without_hash = path_without_hash.replace(
+          os.path.join(root, expected_hash).replace('/', '\\'), root)
+    digest.update(path_without_hash)
     with open(path, 'rb') as f:
       digest.update(f.read())
   return digest.hexdigest()
 
 
+def CalculateToolchainHashes(root):
+  """Calculate the hash of the different toolchains installed in the |root|
+  directory."""
+  hashes = []
+  dir_list = [
+      d for d in os.listdir(root) if os.path.isdir(os.path.join(root, d))]
+  for d in dir_list:
+    hashes.append(CalculateHash(root, d))
+  return hashes
+
+
 def SaveTimestampsAndHash(root, sha1):
   """Saves timestamps and the final hash to be able to early-out more quickly
   next time."""
-  file_list = GetFileList(root)
+  file_list = GetFileList(os.path.join(root, sha1))
   timestamps_data = {
-    'files': [[f, os.stat(f).st_mtime] for f in file_list],
+    'files': [[f, os.path.getmtime(f)] for f in file_list],
     'sha1': sha1,
   }
-  with open(MakeTimestampsFileName(root), 'wb') as f:
+  with open(MakeTimestampsFileName(root, sha1), 'wb') as f:
     json.dump(timestamps_data, f)
 
 
@@ -203,7 +252,12 @@ def DoTreeMirror(target_dir, tree_sha1):
   """In order to save temporary space on bots that do not have enough space to
   download ISOs, unpack them, and copy to the target location, the whole tree
   is uploaded as a zip to internal storage, and then mirrored here."""
-  temp_dir, local_zip = DownloadUsingGsutil(tree_sha1 + '.zip')
+  use_local_zip = bool(int(os.environ.get('USE_LOCAL_ZIP', 0)))
+  if use_local_zip:
+    temp_dir = None
+    local_zip = tree_sha1 + '.zip'
+  else:
+    temp_dir, local_zip = DownloadUsingGsutil(tree_sha1 + '.zip')
   sys.stdout.write('Extracting %s...\n' % local_zip)
   sys.stdout.flush()
   with zipfile.ZipFile(local_zip, 'r', zipfile.ZIP_DEFLATED, True) as zf:
@@ -212,15 +266,129 @@ def DoTreeMirror(target_dir, tree_sha1):
     RmDir(temp_dir)
 
 
-def main():
-  if not sys.platform.startswith(('cygwin', 'win32')):
-    return 0
+def RemoveToolchain(root, sha1, delay_before_removing):
+  """Remove the |sha1| version of the toolchain from |root|."""
+  toolchain_target_dir = os.path.join(root, sha1)
+  if delay_before_removing:
+    DelayBeforeRemoving(toolchain_target_dir)
+  if sys.platform == 'win32':
+    # These stay resident and will make the rmdir below fail.
+    kill_list = [
+      'mspdbsrv.exe',
+      'vctip.exe', # Compiler and tools experience improvement data uploader.
+    ]
+    for process_name in kill_list:
+      with open(os.devnull, 'wb') as nul:
+        subprocess.call(['taskkill', '/f', '/im', process_name],
+                        stdin=nul, stdout=nul, stderr=nul)
+  if os.path.isdir(toolchain_target_dir):
+    RmDir(toolchain_target_dir)
+
+  timestamp_file = MakeTimestampsFileName(root, sha1)
+  if os.path.exists(timestamp_file):
+    os.remove(timestamp_file)
+
+
+def RemoveUnusedToolchains(root):
+  """Remove the versions of the toolchain that haven't been used recently."""
+  valid_toolchains = []
+  dirs_to_remove = []
+
+  for d in os.listdir(root):
+    full_path = os.path.join(root, d)
+    if os.path.isdir(full_path):
+      if not os.path.exists(MakeTimestampsFileName(root, d)):
+        dirs_to_remove.append(d)
+      else:
+        vc_dir = os.path.join(full_path, 'VC')
+        valid_toolchains.append((os.path.getmtime(vc_dir), d))
+    elif os.path.isfile(full_path):
+      os.remove(full_path)
+
+  for d in dirs_to_remove:
+    print ('Removing %s as it doesn\'t correspond to any known toolchain.' %
+           os.path.join(root, d))
+    # Use the RemoveToolchain function to remove these directories as they might
+    # contain an older version of the toolchain.
+    RemoveToolchain(root, d, False)
+
+  # Remove the versions of the toolchains that haven't been used in the past 30
+  # days.
+  toolchain_expiration_time = 60 * 60 * 24 * 30
+  for toolchain in valid_toolchains:
+    toolchain_age_in_sec = time.time() - toolchain[0]
+    if toolchain_age_in_sec > toolchain_expiration_time:
+      print ('Removing version %s of the Win toolchain has it hasn\'t been used'
+             ' in the past %d days.' % (toolchain[1],
+                                        toolchain_age_in_sec / 60 / 60 / 24))
+      RemoveToolchain(root, toolchain[1], True)
+
+
+def GetInstallerName():
+  """Return the name of the Windows 10 Universal C Runtime installer for the
+  current platform, or None if installer is not needed or not applicable.
+  The registry has to be used instead of sys.getwindowsversion() because
+  Python 2.7 is only manifested as being compatible up to Windows 8, so the
+  version APIs helpfully return a maximum of 6.2 (Windows 8).
+  """
+  key_name = r'Software\Microsoft\Windows NT\CurrentVersion'
+  key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_name)
+  value, keytype = winreg.QueryValueEx(key, "CurrentVersion")
+  key.Close()
+  if keytype != winreg.REG_SZ:
+    raise Exception("Unexpected type in registry")
+  if value == '6.1':
+    # Windows 7 and Windows Server 2008 R2
+    return 'Windows6.1-KB2999226-x64.msu'
+  elif value == '6.2':
+    # Windows 8 and Windows Server 2012
+    return 'Windows8-RT-KB2999226-x64.msu'
+  elif value == '6.3':
+    # Windows 8.1, Windows Server 2012 R2, and Windows 10.
+    # The Windows 8.1 installer doesn't work on Windows 10, but it will never
+    # be used because the UCRT is always installed on Windows 10.
+    return 'Windows8.1-KB2999226-x64.msu'
+  else:
+    # Some future OS.
+    return None
+
 
+def InstallUniversalCRTIfNeeded(abs_target_dir):
+  return
+
+
+def EnableCrashDumpCollection():
+  """Tell Windows Error Reporting to record crash dumps so that we can diagnose
+  linker crashes and other toolchain failures. Documented at:
+  https://msdn.microsoft.com/en-us/library/windows/desktop/bb787181.aspx
+  """
+  if sys.platform == 'win32' and os.environ.get('CHROME_HEADLESS') == '1':
+    key_name = r'SOFTWARE\Microsoft\Windows\Windows Error Reporting'
+    try:
+      key = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, key_name)
+      # Merely creating LocalDumps is sufficient to enable the defaults.
+      winreg.CreateKey(key, "LocalDumps")
+      # Disable the WER UI, as documented here:
+      # https://msdn.microsoft.com/en-us/library/windows/desktop/bb513638.aspx
+      winreg.SetValueEx(key, "DontShowUI", 0, winreg.REG_DWORD, 1)
+    # Trap OSError instead of WindowsError so pylint will succeed on Linux.
+    # Catching errors is important because some build machines are not elevated
+    # and writing to HKLM requires elevation.
+    except OSError:
+      pass
+
+
+def main():
   parser = optparse.OptionParser(description=sys.modules[__name__].__doc__)
   parser.add_option('--output-json', metavar='FILE',
                     help='write information about toolchain to FILE')
+  parser.add_option('--force', action='store_true',
+                    help='force script to run on non-Windows hosts')
   options, args = parser.parse_args()
 
+  if not (sys.platform.startswith(('cygwin', 'win32')) or options.force):
+    return 0
+
   if sys.platform == 'cygwin':
     # This script requires Windows Python, so invoke with depot_tools' Python.
     def winpath(path):
@@ -233,10 +401,9 @@ def main():
     sys.exit(subprocess.call(cmd))
   assert sys.platform != 'cygwin'
 
-  # We assume that the Pro hash is the first one.
-  desired_hashes = args
-  if len(desired_hashes) == 0:
-    sys.exit('Desired hashes are required.')
+  if len(args) == 0:
+    sys.exit('Desired hash is required.')
+  desired_hash = args[0]
 
   # Move to depot_tools\win_toolchain where we'll store our files, and where
   # the downloader script is.
@@ -246,7 +413,11 @@ def main():
     target_dir = os.path.normpath(os.path.join(toolchain_dir, 'vs_files'))
   else:
     target_dir = os.path.normpath(os.path.join(toolchain_dir, 'vs2013_files'))
-  abs_target_dir = os.path.abspath(target_dir)
+  if not os.path.isdir(target_dir):
+    os.mkdir(target_dir)
+  toolchain_target_dir = os.path.join(target_dir, desired_hash)
+
+  abs_toolchain_target_dir = os.path.abspath(toolchain_target_dir)
 
   got_new_toolchain = False
 
@@ -254,8 +425,8 @@ def main():
   # Typically this script is only run when the .sha1 one file is updated, but
   # directly calling "gclient runhooks" will also run it, so we cache
   # based on timestamps to make that case fast.
-  current_hash = CalculateHash(target_dir)
-  if current_hash not in desired_hashes:
+  current_hashes = CalculateToolchainHashes(target_dir)
+  if desired_hash not in current_hashes:
     should_use_gs = False
     if (HaveSrcInternalAccess() or
         LooksLikeGoogler() or
@@ -264,66 +435,70 @@ def main():
       if not CanAccessToolchainBucket():
         RequestGsAuthentication()
     if not should_use_gs:
-      print('Please follow the instructions at '
-            'http://www.chromium.org/developers/how-tos/'
-            'build-instructions-windows')
+      print('\n\n\nPlease follow the instructions at '
+            'https://www.chromium.org/developers/how-tos/'
+            'build-instructions-windows\n\n')
       return 1
     print('Windows toolchain out of date or doesn\'t exist, updating (Pro)...')
-    print('  current_hash: %s' % current_hash)
-    print('  desired_hashes: %s' % ', '.join(desired_hashes))
+    print('  current_hashes: %s' % ', '.join(current_hashes))
+    print('  desired_hash: %s' % desired_hash)
     sys.stdout.flush()
-    DelayBeforeRemoving(target_dir)
-    if sys.platform == 'win32':
-      # This stays resident and will make the rmdir below fail.
-      with open(os.devnull, 'wb') as nul:
-        subprocess.call(['taskkill', '/f', '/im', 'mspdbsrv.exe'],
-                        stdin=nul, stdout=nul, stderr=nul)
-    if os.path.isdir(target_dir):
-      RmDir(target_dir)
 
-    DoTreeMirror(target_dir, desired_hashes[0])
+    DoTreeMirror(toolchain_target_dir, desired_hash)
 
     got_new_toolchain = True
 
-  win_sdk = os.path.join(abs_target_dir, 'win_sdk')
+  win_sdk = os.path.join(abs_toolchain_target_dir, 'win_sdk')
   try:
-    with open(os.path.join(target_dir, 'VS_VERSION'), 'rb') as f:
+    version_file = os.path.join(toolchain_target_dir, 'VS_VERSION')
+    vc_dir = os.path.join(toolchain_target_dir, 'VC')
+    with open(version_file, 'rb') as f:
       vs_version = f.read().strip()
+      # Touch the VC directory so we can use its timestamp to know when this
+      # version of the toolchain has been used for the last time.
+    os.utime(vc_dir, None)
   except IOError:
     # Older toolchains didn't have the VS_VERSION file, and used 'win8sdk'
     # instead of just 'win_sdk'.
     vs_version = '2013'
-    win_sdk = os.path.join(abs_target_dir, 'win8sdk')
+    win_sdk = os.path.join(abs_toolchain_target_dir, 'win8sdk')
 
   data = {
-      'path': abs_target_dir,
+      'path': abs_toolchain_target_dir,
       'version': vs_version,
       'win_sdk': win_sdk,
       # Added for backwards compatibility with old toolchain packages.
       'win8sdk': win_sdk,
-      'wdk': os.path.join(abs_target_dir, 'wdk'),
+      'wdk': os.path.join(abs_toolchain_target_dir, 'wdk'),
       'runtime_dirs': [
-        os.path.join(abs_target_dir, 'sys64'),
-        os.path.join(abs_target_dir, 'sys32'),
+        os.path.join(abs_toolchain_target_dir, 'sys64'),
+        os.path.join(abs_toolchain_target_dir, 'sys32'),
       ],
   }
   with open(os.path.join(target_dir, '..', 'data.json'), 'w') as f:
     json.dump(data, f)
 
   if got_new_toolchain:
-    current_hash = CalculateHash(target_dir)
-    if current_hash not in desired_hashes:
+    current_hashes = CalculateToolchainHashes(target_dir)
+    if desired_hash not in current_hashes:
       print >> sys.stderr, (
           'Got wrong hash after pulling a new toolchain. '
-          'Wanted one of \'%s\', got \'%s\'.' % (
-              ', '.join(desired_hashes), current_hash))
+          'Wanted \'%s\', got one of \'%s\'.' % (
+              desired_hash, ', '.join(current_hashes)))
       return 1
-    SaveTimestampsAndHash(target_dir, current_hash)
+    SaveTimestampsAndHash(target_dir, desired_hash)
 
   if options.output_json:
     shutil.copyfile(os.path.join(target_dir, '..', 'data.json'),
                     options.output_json)
 
+  EnableCrashDumpCollection()
+
+  if os.environ.get('GYP_MSVS_VERSION') == '2015':
+    InstallUniversalCRTIfNeeded(abs_toolchain_target_dir)
+
+  RemoveUnusedToolchains(target_dir)
+
   return 0