libv8 7.3.492.27.1 → 8.4.255.0

data/vendor/depot_tools/vpython3.bat

@@ -0,0 +1,12 @@
+@echo off
+:: Copyright 2019 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.
+
+:: TODO(crbug.com/1003139): Remove.
+:: Add Python 3 to PATH to work around crbug.com/1003139.
+for /f %%i in (%~dp0python3_bin_reldir.txt) do set PYTHON3_BIN_RELDIR=%%i
+set PATH=%~dp0%PYTHON3_BIN_RELDIR%;%~dp0%PYTHON3_BIN_RELDIR%\Scripts;%~dp0%PYTHON3_BIN_RELDIR%\DLLs;%PATH%
+
+call "%~dp0\cipd_bin_setup.bat" > nul 2>&1
+"%~dp0\.cipd_bin\vpython3.exe" -vpython-interpreter "%~dp0\%PYTHON3_BIN_RELDIR%\python3.exe" %*

data/vendor/depot_tools/watchlists.py

@@ -6,8 +6,8 @@
 """Watchlists
 
 Watchlists is a mechanism that allow a developer (a "watcher") to watch over
-portions of code that he is interested in. A "watcher" will be cc-ed to
-changes that modify that portion of code, thereby giving him an opportunity
+portions of code that they are interested in. A "watcher" will be cc-ed to
+changes that modify that portion of code, thereby giving them an opportunity
 to make comments on codereview.chromium.org even before the change is
 committed.
 Refer: http://dev.chromium.org/developers/contributing-code/watchlists
@@ -17,6 +17,8 @@ the watchers for files given on the command line. This is useful to verify
 changes to WATCHLISTS files.
 """
 
+from __future__ import print_function
+
 import logging
 import os
 import re
@@ -60,7 +62,7 @@ class Watchlists(object):
       contents = watchlists_file.read()
       watchlists_file.close()
       return contents
-    except IOError, e:
+    except IOError as e:
       logging.error("Cannot read %s: %s" % (self._GetRulesFilePath(), e))
       return ''
 
@@ -73,7 +75,7 @@ class Watchlists(object):
     watchlists_data = None
     try:
       watchlists_data = eval(contents, {'__builtins__': None}, None)
-    except SyntaxError, e:
+    except SyntaxError as e:
       logging.error("Cannot parse %s. %s" % (self._GetRulesFilePath(), e))
       return
 
@@ -92,7 +94,7 @@ class Watchlists(object):
     # Compile the regular expressions ahead of time to avoid creating them
     # on-the-fly multiple times per file.
     self._path_regexps = {}
-    for name, rule in defns.iteritems():
+    for name, rule in defns.items():
       filepath = rule.get('filepath')
       if not filepath:
         continue
@@ -115,23 +117,24 @@ class Watchlists(object):
     watchers = set()  # A set, to avoid duplicates
     for path in paths:
       path = path.replace(os.sep, '/')
-      for name, rule in self._path_regexps.iteritems():
+      for name, rule in self._path_regexps.items():
         if name not in self._watchlists:
           continue
         if rule.search(path):
-          map(watchers.add, self._watchlists[name])
-    return list(watchers)
+          for watchlist in self._watchlists[name]:
+            watchers.add(watchlist)
+    return sorted(watchers)
 
 
 def main(argv):
   # Confirm that watchlists can be parsed and spew out the watchers
   if len(argv) < 2:
-    print "Usage (from the base of repo):"
-    print "  %s [file-1] [file-2] ...." % argv[0]
+    print("Usage (from the base of repo):")
+    print("  %s [file-1] [file-2] ...." % argv[0])
     return 1
   wl = Watchlists(os.getcwd())
   watchers = wl.GetWatchersForPaths(argv[1:])
-  print watchers
+  print(watchers)
 
 
 if __name__ == '__main__':

data/vendor/depot_tools/weekly

@@ -6,6 +6,8 @@
 """Display log of checkins of one particular developer since a particular
 date. Only works on git dependencies at the moment."""
 
+from __future__ import print_function
+
 import gclient_utils
 import optparse
 import os
@@ -25,8 +27,8 @@ def show_log(path, authors, since='1 week ago'):
                             stdout=subprocess.PIPE).communicate()[0].rstrip()
 
   if len(status.splitlines()) > 0:
-    print '---------- %s ----------' % path
-    print status
+    print('---------- %s ----------' % path)
+    print(status)
 
 
 def main():

data/vendor/depot_tools/win32imports.py

@@ -0,0 +1,61 @@
+# Copyright 2020 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.
+"""Win32 functions and constants."""
+
+import ctypes
+import ctypes.wintypes
+
+GENERIC_WRITE = 0x40000000
+CREATE_ALWAYS = 0x00000002
+FILE_ATTRIBUTE_NORMAL = 0x00000080
+LOCKFILE_EXCLUSIVE_LOCK = 0x00000002
+LOCKFILE_FAIL_IMMEDIATELY = 0x00000001
+
+
+class Overlapped(ctypes.Structure):
+  """Overlapped is required and used in LockFileEx and UnlockFileEx."""
+  _fields_ = [('Internal', ctypes.wintypes.LPVOID),
+              ('InternalHigh', ctypes.wintypes.LPVOID),
+              ('Offset', ctypes.wintypes.DWORD),
+              ('OffsetHigh', ctypes.wintypes.DWORD),
+              ('Pointer', ctypes.wintypes.LPVOID),
+              ('hEvent', ctypes.wintypes.HANDLE)]
+
+
+# https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+CreateFileW = ctypes.windll.kernel32.CreateFileW
+CreateFileW.argtypes = [
+    ctypes.wintypes.LPCWSTR,  # lpFileName
+    ctypes.wintypes.DWORD,  # dwDesiredAccess
+    ctypes.wintypes.DWORD,  # dwShareMode
+    ctypes.wintypes.LPVOID,  # lpSecurityAttributes
+    ctypes.wintypes.DWORD,  # dwCreationDisposition
+    ctypes.wintypes.DWORD,  # dwFlagsAndAttributes
+    ctypes.wintypes.LPVOID,  # hTemplateFile
+]
+CreateFileW.restype = ctypes.wintypes.HANDLE
+
+# https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-closehandle
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+CloseHandle.argtypes = [
+    ctypes.wintypes.HANDLE,  # hFile
+]
+CloseHandle.restype = ctypes.wintypes.BOOL
+
+# https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-lockfileex
+LockFileEx = ctypes.windll.kernel32.LockFileEx
+LockFileEx.argtypes = [
+    ctypes.wintypes.HANDLE,  # hFile
+    ctypes.wintypes.DWORD,  # dwFlags
+    ctypes.wintypes.DWORD,  # dwReserved
+    ctypes.wintypes.DWORD,  # nNumberOfBytesToLockLow
+    ctypes.wintypes.DWORD,  # nNumberOfBytesToLockHigh
+    ctypes.POINTER(Overlapped),  # lpOverlapped
+]
+LockFileEx.restype = ctypes.wintypes.BOOL
+
+# Commonly used functions are listed here so callers don't need to import
+# ctypes.
+GetLastError = ctypes.GetLastError
+Handle = ctypes.wintypes.HANDLE

data/vendor/depot_tools/win_toolchain/get_toolchain_if_necessary.py

@@ -26,6 +26,8 @@ future when a hypothetical VS2015 is released, the 2013 script will be
 maintained, and a new 2015 script would be added.
 """
 
+from __future__ import print_function
+
 import hashlib
 import json
 import optparse
@@ -52,12 +54,12 @@ 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 ''
+    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__))
@@ -77,16 +79,19 @@ def GetFileList(root):
   assert os.path.normpath(root) == root
   file_list = []
   # Ignore WER ReportQueue entries that vctip/cl leave in the bin dir if/when
-  # they crash. Also ignores the content of the win_sdk/debuggers/x(86|64)/sym/
-  # directories as this is just the temporarily location that Windbg might use
-  # to store the symbol files.
+  # they crash. Also ignores the content of the
+  # win_sdk/debuggers/x(86|64)/(sym|src)/ directories as this is just the
+  # temporarily location that Windbg might use to store the symbol files and
+  # downloaded sources.
   #
   # Note: These files are only created on a Windows host, so the
   # ignored_directories list isn't relevant on non-Windows hosts.
 
   ignored_directories = ['wer\\reportqueue',
                          'win_sdk\\debuggers\\x86\\sym\\',
-                         'win_sdk\\debuggers\\x64\\sym\\']
+                         'win_sdk\\debuggers\\x64\\sym\\',
+                         'win_sdk\\debuggers\\x86\\src\\',
+                         'win_sdk\\debuggers\\x64\\src\\']
   for base, _, files in os.walk(root):
     paths = [os.path.join(base, f) for f in files]
     for p in paths:
@@ -144,25 +149,25 @@ def CalculateHash(root, expected_hash):
       timestamps_data_files.append(f[0])
     missing_files = [f for f in timestamps_data_files if f not in file_list]
     if len(missing_files):
-      print ('%d files missing from the %s version of the toolchain:' %
+      print('%d files missing from the %s version of the toolchain:' %
              (len(missing_files), expected_hash))
       for f in missing_files[:10]:
-        print '\t%s' % f
+        print('\t%s' % f)
       if len(missing_files) > 10:
-        print '\t...'
+        print('\t...')
     extra_files = [f for f in file_list if f not in timestamps_data_files]
     if len(extra_files):
-      print ('%d extra files in the %s version of the toolchain:' %
+      print('%d extra files in the %s version of the toolchain:' %
              (len(extra_files), expected_hash))
       for f in extra_files[:10]:
-        print '\t%s' % f
+        print('\t%s' % f)
       if len(extra_files) > 10:
-        print '\t...'
+        print('\t...')
   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
+  print('Calculating hash of toolchain in %s. Please wait...' % full_root_path)
   sys.stdout.flush()
   digest = hashlib.sha1()
   for path in file_list:
@@ -170,7 +175,10 @@ def CalculateHash(root, expected_hash):
     if expected_hash:
       path_without_hash = path_without_hash.replace(
           os.path.join(root, expected_hash).replace('/', '\\'), root)
-    digest.update(path_without_hash.lower())
+    if sys.version_info[0] < 3:
+      digest.update(path_without_hash.lower())
+    else:
+      digest.update(bytes(path_without_hash.lower(), 'utf-8'))
     with open(path, 'rb') as f:
       digest.update(f.read())
 
@@ -189,7 +197,7 @@ def CalculateToolchainHashes(root, remove_corrupt_toolchains):
   for d in dir_list:
     toolchain_hash = CalculateHash(root, d)
     if toolchain_hash != d:
-      print ('The hash of a version of the toolchain has an unexpected value ('
+      print('The hash of a version of the toolchain has an unexpected value ('
              '%s instead of %s)%s.' % (toolchain_hash, d,
              ', removing it' if remove_corrupt_toolchains else ''))
       if remove_corrupt_toolchains:
@@ -259,23 +267,23 @@ def RequestGsAuthentication():
   Googler. This allows much faster downloads, and pulling (old) toolchains
   that match src/ revisions.
   """
-  print 'Access to gs://chrome-wintoolchain/ not configured.'
-  print '-----------------------------------------------------------------'
-  print
-  print 'You appear to be a Googler.'
-  print
-  print 'I\'m sorry for the hassle, but you need to do a one-time manual'
-  print 'authentication. Please run:'
-  print
-  print '    download_from_google_storage --config'
-  print
-  print 'and follow the instructions.'
-  print
-  print 'NOTE 1: Use your google.com credentials, not chromium.org.'
-  print 'NOTE 2: Enter 0 when asked for a "project-id".'
-  print
-  print '-----------------------------------------------------------------'
-  print
+  print('Access to gs://chrome-wintoolchain/ not configured.')
+  print('-----------------------------------------------------------------')
+  print()
+  print('You appear to be a Googler.')
+  print()
+  print('I\'m sorry for the hassle, but you need to do a one-time manual')
+  print('authentication. Please run:')
+  print()
+  print('    download_from_google_storage --config')
+  print()
+  print('and follow the instructions.')
+  print()
+  print('NOTE 1: Use your google.com credentials, not chromium.org.')
+  print('NOTE 2: Enter 0 when asked for a "project-id".')
+  print()
+  print('-----------------------------------------------------------------')
+  print()
   sys.stdout.flush()
   sys.exit(1)
 
@@ -289,7 +297,7 @@ def DelayBeforeRemoving(target_dir):
               '\rRemoving old toolchain in %ds... (Ctrl-C to cancel)' % i)
       sys.stdout.flush()
       time.sleep(1)
-    print
+    print()
 
 
 def DownloadUsingHttp(filename):
@@ -396,7 +404,7 @@ def RemoveUnusedToolchains(root):
       os.remove(full_path)
 
   for d in dirs_to_remove:
-    print ('Removing %s as it doesn\'t correspond to any known toolchain.' %
+    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.
@@ -408,7 +416,7 @@ def RemoveUnusedToolchains(root):
   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 as it hasn\'t been used'
+      print('Removing version %s of the Win toolchain as it hasn\'t been used'
              ' in the past %d days.' % (toolchain[1],
                                         toolchain_age_in_sec / 60 / 60 / 24))
       RemoveToolchain(root, toolchain[1], True)
@@ -569,10 +577,10 @@ def main():
   if got_new_toolchain:
     current_hashes = CalculateToolchainHashes(target_dir, False)
     if desired_hash not in current_hashes:
-      print >> sys.stderr, (
+      print(
           'Got wrong hash after pulling a new toolchain. '
           'Wanted \'%s\', got one of \'%s\'.' % (
-              desired_hash, ', '.join(current_hashes)))
+              desired_hash, ', '.join(current_hashes)), file=sys.stderr)
       return 1
     SaveTimestampsAndHash(target_dir, desired_hash)
 

data/vendor/depot_tools/win_toolchain/package_from_installed.py

@@ -9,7 +9,7 @@ into a .zip file.
 It assumes default install locations for tools, on the C: drive.
 
 1. Start from a fresh Windows VM image.
-2. Download the VS 2017 installer. Run the installer with these parameters:
+2. Download the VS installer. Run the installer with these parameters:
     --add Microsoft.VisualStudio.Workload.NativeDesktop
     --add Microsoft.VisualStudio.Component.VC.ATLMFC
     --add Microsoft.VisualStudio.Component.VC.Tools.ARM64
@@ -23,13 +23,15 @@ frameworks-> Visual C++ MFC for ARM64 (which also brings in ATL for ARM64).
 3. Use Add or Remove Programs to find the Windows SDK installed with VS
 and modify it to include the debuggers.
 4. Run this script, which will build a <sha1>.zip, something like this:
-  python package_from_installed.py 2017 -w 10.0.17763.0
+  python package_from_installed.py 2017|2019 -w 10.0.17763.0|<SDK version>
 
 Express is not yet supported by this script, but patches welcome (it's not too
 useful as the resulting zip can't be redistributed, and most will presumably
 have a Pro license anyway).
 """
 
+from __future__ import print_function
+
 import collections
 import glob
 import json
@@ -48,24 +50,21 @@ import get_toolchain_if_necessary
 VS_VERSION = None
 WIN_VERSION = None
 VC_TOOLS = None
+SUPPORTED_VS_VERSIONS = ['2017', '2019']
 
 
 def GetVSPath():
-  if VS_VERSION == '2015':
-    return r'C:\Program Files (x86)\Microsoft Visual Studio 14.0'
-  elif VS_VERSION == '2017':
-    # Use vswhere to find the VS 2017 installation. This will find prerelease
-    # versions because -prerelease is specified. This assumes that only one
-    # version is installed.
-    command = (r'C:\Program Files (x86)\Microsoft Visual Studio\Installer'
-               r'\vswhere.exe -prerelease')
-    marker = 'installationPath: '
-    for line in subprocess.check_output(command).splitlines():
-      if line.startswith(marker):
-        return line[len(marker):]
-    raise Exception('VS 2017 path not found in vswhere output')
-  else:
-    raise ValueError(VS_VERSION)
+  # Use vswhere to find the VS installation. This will find prerelease
+  # versions because -prerelease is specified. This assumes that only one
+  # version is installed.
+  command = (r'C:\Program Files (x86)\Microsoft Visual Studio\Installer'
+             r'\vswhere.exe -prerelease')
+  marker = 'installationPath: '
+  output = subprocess.check_output(command, universal_newlines=True)
+  for line in output.splitlines():
+    if line.startswith(marker):
+      return line[len(marker):]
+  raise Exception('VS %s path not found in vswhere output' % (VS_VERSION))
 
 
 def ExpandWildcards(root, sub_dir):
@@ -81,6 +80,12 @@ def BuildRepackageFileList(src_dir):
   # Strip off a trailing slash if present
   if src_dir.endswith('\\'):
     src_dir = src_dir[:-1]
+
+  # Ensure .\win_sdk\Debuggers exists and fail to repackage if it doesn't.
+  debuggers_path = os.path.join(src_dir, 'win_sdk', 'Debuggers')
+  if not os.path.exists(debuggers_path):
+    raise Exception('Repacking failed. Missing %s.' % (debuggers_path))
+
   result = []
   for root, _, files in os.walk(src_dir):
     for f in files:
@@ -90,7 +95,7 @@ def BuildRepackageFileList(src_dir):
   return result
 
 
-def BuildFileList(override_dir):
+def BuildFileList(override_dir, include_arm):
   result = []
 
   # Subset of VS corresponding roughly to VC.
@@ -117,39 +122,27 @@ def BuildFileList(override_dir):
         VC_TOOLS + '/lib',
     ]
 
-  if VS_VERSION == '2015':
-    paths += [
-        ('VC/redist/x86/Microsoft.VC140.CRT', 'sys32'),
-        ('VC/redist/x86/Microsoft.VC140.CRT', 'win_sdk/bin/x86'),
-        ('VC/redist/x86/Microsoft.VC140.MFC', 'sys32'),
-        ('VC/redist/debug_nonredist/x86/Microsoft.VC140.DebugCRT', 'sys32'),
-        ('VC/redist/debug_nonredist/x86/Microsoft.VC140.DebugMFC', 'sys32'),
-        ('VC/redist/x64/Microsoft.VC140.CRT', 'sys64'),
-        ('VC/redist/x64/Microsoft.VC140.CRT', 'VC/bin/amd64_x86'),
-        ('VC/redist/x64/Microsoft.VC140.CRT', 'VC/bin/amd64'),
-        ('VC/redist/x64/Microsoft.VC140.CRT', 'win_sdk/bin/x64'),
-        ('VC/redist/x64/Microsoft.VC140.MFC', 'sys64'),
-        ('VC/redist/debug_nonredist/x64/Microsoft.VC140.DebugCRT', 'sys64'),
-        ('VC/redist/debug_nonredist/x64/Microsoft.VC140.DebugMFC', 'sys64'),
-    ]
-  elif VS_VERSION == '2017':
+  paths += [
+      ('VC/redist/MSVC/14.*.*/x86/Microsoft.VC*.CRT', 'sys32'),
+      ('VC/redist/MSVC/14.*.*/x86/Microsoft.VC*.CRT', 'win_sdk/bin/x86'),
+      ('VC/redist/MSVC/14.*.*/debug_nonredist/x86/Microsoft.VC*.DebugCRT',
+       'sys32'),
+      ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'sys64'),
+      ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'VC/bin/amd64_x86'),
+      ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'VC/bin/amd64'),
+      ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'win_sdk/bin/x64'),
+      ('VC/redist/MSVC/14.*.*/debug_nonredist/x64/Microsoft.VC*.DebugCRT',
+       'sys64'),
+  ]
+  if include_arm:
     paths += [
-        ('VC/redist/MSVC/14.*.*/x86/Microsoft.VC*.CRT', 'sys32'),
-        ('VC/redist/MSVC/14.*.*/x86/Microsoft.VC*.CRT', 'win_sdk/bin/x86'),
-        ('VC/redist/MSVC/14.*.*/debug_nonredist/x86/Microsoft.VC*.DebugCRT', 'sys32'),
-        ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'sys64'),
-        ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'VC/bin/amd64_x86'),
-        ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'VC/bin/amd64'),
-        ('VC/redist/MSVC/14.*.*/x64/Microsoft.VC*.CRT', 'win_sdk/bin/x64'),
-        ('VC/redist/MSVC/14.*.*/debug_nonredist/x64/Microsoft.VC*.DebugCRT', 'sys64'),
         ('VC/redist/MSVC/14.*.*/arm64/Microsoft.VC*.CRT', 'sysarm64'),
         ('VC/redist/MSVC/14.*.*/arm64/Microsoft.VC*.CRT', 'VC/bin/amd64_arm64'),
         ('VC/redist/MSVC/14.*.*/arm64/Microsoft.VC*.CRT', 'VC/bin/arm64'),
         ('VC/redist/MSVC/14.*.*/arm64/Microsoft.VC*.CRT', 'win_sdk/bin/arm64'),
-        ('VC/redist/MSVC/14.*.*/debug_nonredist/arm64/Microsoft.VC*.DebugCRT', 'sysarm64'),
+        ('VC/redist/MSVC/14.*.*/debug_nonredist/arm64/Microsoft.VC*.DebugCRT',
+         'sysarm64'),
     ]
-  else:
-    raise ValueError('VS_VERSION %s' % VS_VERSION)
 
   vs_path = GetVSPath()
 
@@ -180,6 +173,10 @@ def BuildFileList(override_dir):
           result.append((final_from, dest))
 
   sdk_path = r'C:\Program Files (x86)\Windows Kits\10'
+  debuggers_path = os.path.join(sdk_path, 'Debuggers')
+  if not os.path.exists(debuggers_path):
+    raise Exception('Packaging failed. Missing %s.' % (debuggers_path))
+
   for root, _, files in os.walk(sdk_path):
     for f in files:
       combined = os.path.normpath(os.path.join(root, f))
@@ -236,21 +233,31 @@ def BuildFileList(override_dir):
       # Needed to let debug binaries run.
       'ucrtbased.dll',
   ]
+  cpu_pairs = [
+    ('x86', 'sys32'),
+    ('x64', 'sys64'),
+  ]
+  if include_arm:
+    cpu_pairs += [
+      ('arm64', 'sysarm64'),
+    ]
   for system_crt_file in system_crt_files:
-    for cpu_pair in [('x86', 'sys32'), ('x64', 'sys64'), ('arm64', 'sysarm64')]:
+    for cpu_pair in cpu_pairs:
       target_cpu, dest_dir = cpu_pair
       src_path = os.path.join(sdk_path, 'bin', WIN_VERSION, target_cpu, 'ucrt')
       result.append((os.path.join(src_path, system_crt_file),
                      os.path.join(dest_dir, system_crt_file)))
 
   # Generically drop all arm stuff that we don't need, and
-  # drop .msi files because we don't need installers, and drop windows.winmd
-  # because it is unneeded and is different on every machine.
-  return [(f, t) for f, t in result if 'arm\\' not in f.lower() and
-                                       not f.lower().endswith('.msi') and
-                                       not f.lower().endswith('.msm') and
-                                       not f.lower().endswith('windows.winmd')]
-
+  # drop .msi files because we don't need installers and drop
+  # samples since those are not used by any tools.
+  def is_skippable(f):
+    return ('arm\\' in f.lower() or
+            (not include_arm and 'arm64\\' in f.lower()) or
+            'samples\\' in f.lower() or
+            f.lower().endswith(('.msi',
+                                '.msm')))
+  return [(f, t) for f, t in result if not is_skippable(f)]
 
 def GenerateSetEnvCmd(target_dir):
   """Generate a batch file that gyp expects to exist to set up the compiler
@@ -271,6 +278,10 @@ def GenerateSetEnvCmd(target_dir):
     ['..', '..'] + vc_tools_parts + ['include'],
     ['..', '..'] + vc_tools_parts + ['atlmfc', 'include'],
   ])
+  libpath_dirs = [
+    ['..', '..'] + vc_tools_parts + ['lib', 'x86', 'store', 'references'],
+    ['..', '..', 'win_sdk', 'UnionMetadata', WIN_VERSION],
+  ]
   # Common to x86, x64, and arm64
   env = collections.OrderedDict([
     # Yuck: These have a trailing \ character. No good way to represent this in
@@ -278,122 +289,100 @@ def GenerateSetEnvCmd(target_dir):
     ('VSINSTALLDIR', [['..', '..\\']]),
     ('VCINSTALLDIR', [['..', '..', 'VC\\']]),
     ('INCLUDE', include_dirs),
+    ('LIBPATH', libpath_dirs),
   ])
   # x86. Always use amd64_x86 cross, not x86 on x86.
-  if VS_VERSION == '2017':
-    env['VCToolsInstallDir'] = [['..', '..'] + vc_tools_parts[:]]
-    # Yuck: This one ends in a slash as well.
-    env['VCToolsInstallDir'][0][-1] += '\\'
-    env_x86 = collections.OrderedDict([
-      ('PATH', [
-        ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
-        ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x86'],
-        ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x64'],  # Needed for mspdb1x0.dll.
-      ]),
+  env['VCToolsInstallDir'] = [['..', '..'] + vc_tools_parts[:]]
+  # Yuck: This one ends in a slash as well.
+  env['VCToolsInstallDir'][0][-1] += '\\'
+  env_x86 = collections.OrderedDict([
+      (
+          'PATH',
+          [
+              ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
+              ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x86'],
+              ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x64'
+                                              ],  # Needed for mspdb1x0.dll.
+          ]),
       ('LIB', [
-        ['..', '..'] + vc_tools_parts + ['lib', 'x86'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'x86'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'x86'],
-        ['..', '..'] + vc_tools_parts + ['atlmfc', 'lib', 'x86'],
+          ['..', '..'] + vc_tools_parts + ['lib', 'x86'],
+          ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'x86'],
+          ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'x86'],
+          ['..', '..'] + vc_tools_parts + ['atlmfc', 'lib', 'x86'],
       ]),
-    ])
-  else:
-    env_x86 = collections.OrderedDict([
-      ('PATH', [
-        ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x86'],
-        ['..', '..', 'VC', 'bin', 'amd64_x86'],
-        ['..', '..', 'VC', 'bin', 'amd64'],  # Needed for mspdb1x0.dll.
-      ]),
-      ('LIB', [
-        ['..', '..', 'VC', 'lib'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'x86'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'x86'],
-        ['..', '..', 'VC', 'atlmfc', 'lib'],
-      ]),
-    ])
+  ])
+
   # x64.
-  if VS_VERSION == '2017':
-    env_x64 = collections.OrderedDict([
+  env_x64 = collections.OrderedDict([
       ('PATH', [
-        ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
-        ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x64'],
+          ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
+          ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x64'],
       ]),
       ('LIB', [
-        ['..', '..'] + vc_tools_parts + ['lib', 'x64'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'x64'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'x64'],
-        ['..', '..'] + vc_tools_parts + ['atlmfc', 'lib', 'x64'],
+          ['..', '..'] + vc_tools_parts + ['lib', 'x64'],
+          ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'x64'],
+          ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'x64'],
+          ['..', '..'] + vc_tools_parts + ['atlmfc', 'lib', 'x64'],
       ]),
-    ])
-  else:
-    env_x64 = collections.OrderedDict([
-      ('PATH', [
-        ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
-        ['..', '..', 'VC', 'bin', 'amd64'],
-      ]),
-      ('LIB', [
-        ['..', '..', 'VC', 'lib', 'amd64'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'x64'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'x64'],
-        ['..', '..', 'VC', 'atlmfc', 'lib', 'amd64'],
-      ]),
-    ])
-  if VS_VERSION == '2017':
-    env_arm64 = collections.OrderedDict([
+  ])
+
+  # arm64.
+  env_arm64 = collections.OrderedDict([
       ('PATH', [
-        ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
-        ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'arm64'],
-        ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x64'],
+          ['..', '..', 'win_sdk', 'bin', WIN_VERSION, 'x64'],
+          ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'arm64'],
+          ['..', '..'] + vc_tools_parts + ['bin', 'HostX64', 'x64'],
       ]),
       ('LIB', [
-        ['..', '..'] + vc_tools_parts + ['lib', 'arm64'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'arm64'],
-        ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'arm64'],
-        ['..', '..'] + vc_tools_parts + ['atlmfc', 'lib', 'arm64'],
+          ['..', '..'] + vc_tools_parts + ['lib', 'arm64'],
+          ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'um', 'arm64'],
+          ['..', '..', 'win_sdk', 'Lib', WIN_VERSION, 'ucrt', 'arm64'],
+          ['..', '..'] + vc_tools_parts + ['atlmfc', 'lib', 'arm64'],
       ]),
-    ])
+  ])
+
   def BatDirs(dirs):
     return ';'.join(['%~dp0' + os.path.join(*d) for d in dirs])
   set_env_prefix = os.path.join(target_dir, r'win_sdk\bin\SetEnv')
   with open(set_env_prefix + '.cmd', 'w') as f:
     f.write('@echo off\n'
             ':: Generated by win_toolchain\\package_from_installed.py.\n')
-    for var, dirs in env.iteritems():
+    for var, dirs in env.items():
       f.write('set %s=%s\n' % (var, BatDirs(dirs)))
     f.write('if "%1"=="/x64" goto x64\n')
     f.write('if "%1"=="/arm64" goto arm64\n')
 
-    for var, dirs in env_x86.iteritems():
+    for var, dirs in env_x86.items():
       f.write('set %s=%s%s\n' % (
           var, BatDirs(dirs), ';%PATH%' if var == 'PATH' else ''))
     f.write('goto :EOF\n')
 
     f.write(':x64\n')
-    for var, dirs in env_x64.iteritems():
+    for var, dirs in env_x64.items():
       f.write('set %s=%s%s\n' % (
           var, BatDirs(dirs), ';%PATH%' if var == 'PATH' else ''))
     f.write('goto :EOF\n')
 
     f.write(':arm64\n')
-    for var, dirs in env_arm64.iteritems():
+    for var, dirs in env_arm64.items():
       f.write('set %s=%s%s\n' % (
           var, BatDirs(dirs), ';%PATH%' if var == 'PATH' else ''))
     f.write('goto :EOF\n')
-  with open(set_env_prefix + '.x86.json', 'wb') as f:
+  with open(set_env_prefix + '.x86.json', 'wt', newline='') as f:
     assert not set(env.keys()) & set(env_x86.keys()), 'dupe keys'
-    json.dump({'env': collections.OrderedDict(env.items() + env_x86.items())},
+    json.dump({'env': collections.OrderedDict(list(env.items()) + list(env_x86.items()))},
               f)
-  with open(set_env_prefix + '.x64.json', 'wb') as f:
+  with open(set_env_prefix + '.x64.json', 'wt', newline='') as f:
     assert not set(env.keys()) & set(env_x64.keys()), 'dupe keys'
-    json.dump({'env': collections.OrderedDict(env.items() + env_x64.items())},
+    json.dump({'env': collections.OrderedDict(list(env.items()) + list(env_x64.items()))},
               f)
-  with open(set_env_prefix + '.arm64.json', 'wb') as f:
+  with open(set_env_prefix + '.arm64.json', 'wt', newline='') as f:
     assert not set(env.keys()) & set(env_arm64.keys()), 'dupe keys'
-    json.dump({'env': collections.OrderedDict(env.items() + env_arm64.items())},
+    json.dump({'env': collections.OrderedDict(list(env.items()) + list(env_arm64.items()))},
               f)
 
 
-def AddEnvSetup(files):
+def AddEnvSetup(files, include_arm):
   """We need to generate this file in the same way that the "from pieces"
   script does, so pull that in here."""
   tempdir = tempfile.mkdtemp()
@@ -405,18 +394,19 @@ def AddEnvSetup(files):
                 'win_sdk\\bin\\SetEnv.x86.json'))
   files.append((os.path.join(tempdir, 'win_sdk', 'bin', 'SetEnv.x64.json'),
                 'win_sdk\\bin\\SetEnv.x64.json'))
-  files.append((os.path.join(tempdir, 'win_sdk', 'bin', 'SetEnv.arm64.json'),
-                'win_sdk\\bin\\SetEnv.arm64.json'))
+  if include_arm:
+    files.append((os.path.join(tempdir, 'win_sdk', 'bin', 'SetEnv.arm64.json'),
+                  'win_sdk\\bin\\SetEnv.arm64.json'))
   vs_version_file = os.path.join(tempdir, 'VS_VERSION')
-  with open(vs_version_file, 'wb') as version:
-    print >>version, VS_VERSION
+  with open(vs_version_file, 'wt', newline='') as version:
+    print(VS_VERSION, file=version)
   files.append((vs_version_file, 'VS_VERSION'))
 
 
 def RenameToSha1(output):
   """Determine the hash in the same way that the unzipper does to rename the
   # .zip file."""
-  print 'Extracting to determine hash...'
+  print('Extracting to determine hash...')
   tempdir = tempfile.mkdtemp()
   old_dir = os.getcwd()
   os.chdir(tempdir)
@@ -424,24 +414,30 @@ def RenameToSha1(output):
   with zipfile.ZipFile(
       os.path.join(old_dir, output), 'r', zipfile.ZIP_DEFLATED, True) as zf:
     zf.extractall(rel_dir)
-  print 'Hashing...'
+  print('Hashing...')
   sha1 = get_toolchain_if_necessary.CalculateHash(rel_dir, None)
   os.chdir(old_dir)
   shutil.rmtree(tempdir)
   final_name = sha1 + '.zip'
   os.rename(output, final_name)
-  print 'Renamed %s to %s.' % (output, final_name)
+  print('Renamed %s to %s.' % (output, final_name))
 
 
 def main():
-  usage = 'usage: %prog [options] 2015|2017'
+  if sys.version_info[0] < 3:
+    print('This script requires Python 3')
+    sys.exit(10)
+  usage = 'usage: %prog [options] 2017|2019'
   parser = optparse.OptionParser(usage)
   parser.add_option('-w', '--winver', action='store', type='string',
-                    dest='winver', default='10.0.14393.0',
-                    help='Windows SDK version, such as 10.0.14393.0')
+                    dest='winver', default='10.0.18362.0',
+                    help='Windows SDK version, such as 10.0.18362.0')
   parser.add_option('-d', '--dryrun', action='store_true', dest='dryrun',
                     default=False,
                     help='scan for file existence and prints statistics')
+  parser.add_option('--noarm', action='store_false', dest='arm',
+                    default=True,
+                    help='Avoids arm parts of the SDK')
   parser.add_option('--override', action='store', type='string',
                     dest='override_dir', default=None,
                     help='Specify alternate bin/include/lib directory')
@@ -453,8 +449,8 @@ def main():
   if options.repackage_dir:
     files = BuildRepackageFileList(options.repackage_dir)
   else:
-    if len(args) != 1 or args[0] not in ('2015', '2017'):
-      print 'Must specify 2015 or 2017'
+    if len(args) != 1 or args[0] not in SUPPORTED_VS_VERSIONS:
+      print('Must specify 2017 or 2019')
       parser.print_help();
       return 1
 
@@ -462,7 +458,7 @@ def main():
       if (not os.path.exists(os.path.join(options.override_dir, 'bin')) or
           not os.path.exists(os.path.join(options.override_dir, 'include')) or
           not os.path.exists(os.path.join(options.override_dir, 'lib'))):
-        print 'Invalid override directory - must contain bin/include/lib dirs'
+        print('Invalid override directory - must contain bin/include/lib dirs')
         return 1
 
     global VS_VERSION
@@ -470,22 +466,19 @@ def main():
     global WIN_VERSION
     WIN_VERSION = options.winver
     global VC_TOOLS
-    if VS_VERSION == '2017':
-      vs_path = GetVSPath()
-      temp_tools_path = ExpandWildcards(vs_path, 'VC/Tools/MSVC/14.*.*')
-      # Strip off the leading vs_path characters and switch back to / separators.
-      VC_TOOLS = temp_tools_path[len(vs_path) + 1:].replace('\\', '/')
-    else:
-      VC_TOOLS = 'VC'
+    vs_path = GetVSPath()
+    temp_tools_path = ExpandWildcards(vs_path, 'VC/Tools/MSVC/14.*.*')
+    # Strip off the leading vs_path characters and switch back to / separators.
+    VC_TOOLS = temp_tools_path[len(vs_path) + 1:].replace('\\', '/')
 
-    print 'Building file list for VS %s Windows %s...' % (VS_VERSION, WIN_VERSION)
-    files = BuildFileList(options.override_dir)
+    print('Building file list for VS %s Windows %s...' % (VS_VERSION, WIN_VERSION))
+    files = BuildFileList(options.override_dir, options.arm)
 
-    AddEnvSetup(files)
+    AddEnvSetup(files, options.arm)
 
   if False:
     for f in files:
-      print f[0], '->', f[1]
+      print(f[0], '->', f[1])
     return 0
 
   output = 'out.zip'