build with MSVS will only need VS console environment set up

build/vs_toolchain.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 import glob
 import json
 import os
 import pipes
 import platform
@@ skipping 19 matching lines @@
   returns the location of the VS runtime DLLs so they can be copied into
   the output directory after gyp generation.
 
   Return value is [x64path, x86path] or None
   """
   vs_runtime_dll_dirs = None
   depot_tools_win_toolchain = \
       bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
   # When running on a non-Windows host, only do this if the SDK has explicitly
   # been downloaded before (in which case json_data_file will exist).
-  if ((sys.platform in ('win32', 'cygwin') or os.path.exists(json_data_file))
-      and depot_tools_win_toolchain):
+  if (depot_tools_win_toolchain and (sys.platform in ('win32', 'cygwin')
+                                     or os.path.exists(json_data_file))):
     if ShouldUpdateToolchain():
       Update()
     with open(json_data_file, 'r') as tempf:
       toolchain_data = json.load(tempf)
 
     toolchain = toolchain_data['path']
     version = toolchain_data['version']
     win_sdk = toolchain_data.get('win_sdk')
     if not win_sdk:
       win_sdk = toolchain_data['win8sdk']
@@ skipping 13 matching lines @@
 
     # We need to make sure windows_sdk_path is set to the automated
     # toolchain values in GYP_DEFINES, but don't want to override any
     # otheroptions.express
     # values there.
     gyp_defines_dict = gyp.NameValueListToDict(gyp.ShlexEnv('GYP_DEFINES'))
     gyp_defines_dict['windows_sdk_path'] = win_sdk
     os.environ['GYP_DEFINES'] = ' '.join('%s=%s' % (k, pipes.quote(str(v)))
         for k, v in gyp_defines_dict.iteritems())
 
-    os.environ['WINDOWSSDKDIR'] = win_sdk
+    os.environ['WindowsSdkDir'] = win_sdk
     os.environ['WDK_DIR'] = wdk
     # Include the VS runtime in the PATH in case it's not machine-installed.
     runtime_path = os.path.pathsep.join(vs_runtime_dll_dirs)
     os.environ['PATH'] = runtime_path + os.path.pathsep + os.environ['PATH']
   elif sys.platform == 'win32' and not depot_tools_win_toolchain:
-    if not 'GYP_MSVS_OVERRIDE_PATH' in os.environ:
-      os.environ['GYP_MSVS_OVERRIDE_PATH'] = DetectVisualStudioPath()
-    if not 'GYP_MSVS_VERSION' in os.environ:
-      os.environ['GYP_MSVS_VERSION'] = GetVisualStudioVersion()
+    GetVisualStudioVersion()
+    DetectVisualStudioPath()
 
     # When using an installed toolchain these files aren't needed in the output
     # directory in order to run binaries locally, but they are needed in order
     # to create isolates or the mini_installer. Copying them to the output
     # directory ensures that they are available when needed.
     bitness = platform.architecture()[0]
     # When running 64-bit python the x64 DLLs will be in System32
     x64_path = 'System32' if bitness == '64bit' else 'Sysnative'
     x64_path = os.path.join(r'C:\Windows', x64_path)
     vs_runtime_dll_dirs = [x64_path, r'C:\Windows\SysWOW64']
@@ skipping 20 matching lines @@
   except WindowsError:
     return None
 
 
 def _RegistryGetValue(key, value):
   try:
     return _RegistryGetValueUsingWinReg(key, value)
   except ImportError:
     raise Exception('The python library _winreg not found.')
 
-
+year_to_version = {
+    '2013': '12.0',
+    '2015': '14.0',
+    '2017': '15.0',
+}
 def GetVisualStudioVersion():
   """Return GYP_MSVS_VERSION of Visual Studio.
   """
-  return os.environ.get('GYP_MSVS_VERSION', CURRENT_DEFAULT_TOOLCHAIN_VERSION)
+  if 'VisualStudioVersion' not in os.environ:
+    raise ValueError('Please run from within a VS console (with ENV variables)')
+
+  ver = os.environ['VisualStudioVersion']
+  year = year_to_version.keys()[year_to_version.values().index(ver)]
+
+  if year not in year_to_version:
+    years = ', '.join(year_to_version.keys())
+    raise ValueError('Visual Studio version %s not supported.'
+                     'Supported versions are: %s' % (year, years))
+
+  if 'GYP_MSVS_VERSION' in os.environ:
+    wanted = os.environ.get('GYP_MSVS_VERSION')
+    if wanted != year:
+      raise ValueError('GYP_MSVS_VERSION does not match VS console version'
+                       '%s != %s(%s)' % (wanted, year, ver))
+  else:
+    os.environ['GYP_MSVS_VERSION'] = year
+
+  return year
 
 
 def DetectVisualStudioPath():
   """Return path to the GYP_MSVS_VERSION of Visual Studio.
   """
 
   # Note that this code is used from
   # build/toolchain/win/setup_toolchain.py as well.
-  version_as_year = GetVisualStudioVersion()
-  year_to_version = {
-      '2013': '12.0',
-      '2015': '14.0',
-      '2017': '15.0',
-  }
-  if version_as_year not in year_to_version:
-    raise Exception(('Visual Studio version %s (from GYP_MSVS_VERSION)'
-                     ' not supported. Supported versions are: %s') % (
-                       version_as_year, ', '.join(year_to_version.keys())))
-  version = year_to_version[version_as_year]
-  if version_as_year == '2017':
-    # The VC++ 2017 install location needs to be located using COM instead of
-    # the registry. For details see:
-    # https://blogs.msdn.microsoft.com/heaths/2016/09/15/changes-to-visual-studio-15-setup/
-    # For now we use a hardcoded default with an environment variable override.
-    path = r'C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional'
-    path = os.environ.get('vs2017_install', path)
-    if os.path.exists(path):
-      return path
+  GetVisualStudioVersion()
+  if 'VSINSTALLDIR' not in os.environ:
+    raise ValueError('Please run from within a VS console (with ENV variables)')
+  if 'GYP_MSVS_OVERRIDE_PATH' in os.environ:
+    path = os.environ['GYP_MSVS_OVERRIDE_PATH']
   else:
-    keys = [r'HKLM\Software\Microsoft\VisualStudio\%s' % version,
-            r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s' % version]
-    for key in keys:
-      path = _RegistryGetValue(key, 'InstallDir')
-      if not path:
-        continue
-      path = os.path.normpath(os.path.join(path, '..', '..'))
-      return path
+    path = os.environ['VSINSTALLDIR']
+    os.environ['GYP_MSVS_OVERRIDE_PATH'] = path
 
-  raise Exception(('Visual Studio Version %s (from GYP_MSVS_VERSION)'
-                   ' not found.') % (version_as_year))
+  return path
 
-
-def _VersionNumber():
+def _SdkFileSuffix():

[brucedawson, 2017/03/27 23:23:52]

This needs a larger comment to explain what this number means. In some contexts
2017 increases 140 to 141, and in other contexts it leaves it at 140. This
particular context is, I believe, not SDK files but CRT files.

So, I think this function needs renaming.

   """Gets the standard version number ('120', '140', etc.) based on
   GYP_MSVS_VERSION."""
   vs_version = GetVisualStudioVersion()
   if vs_version == '2013':
     return '120'
   if vs_version == '2015':
     return '140'
+  # even on 2017 (a.k.a. vc1410 version of files is 140)
   if vs_version == '2017':
-    return '150'
+    return '140'
   raise ValueError('Unexpected GYP_MSVS_VERSION')
 
 
 def _CopyRuntimeImpl(target, source, verbose=True):
   """Copy |source| to |target| if it doesn't already exist or if it needs to be
   updated (comparing last modified time as an approximate float match as for
   some reason the values tend to differ by ~1e-07 despite being copies of the
   same file... https://crbug.com/603603).
   """
   if (os.path.isdir(os.path.dirname(target)) and
@@ skipping 24 matching lines @@
   """Copy both the msvcp and vccorlib runtime DLLs, only if the target doesn't
   exist, but the target directory does exist."""
   for file_part in ('msvcp', 'vccorlib', 'vcruntime'):
     dll = dll_pattern % file_part
     target = os.path.join(target_dir, dll)
     source = os.path.join(source_dir, dll)
     _CopyRuntimeImpl(target, source)
   # Copy the UCRT files needed by VS 2015 from the Windows SDK. This location
   # includes the api-ms-win-crt-*.dll files that are not found in the Windows
   # directory. These files are needed for component builds.
-  # If WINDOWSSDKDIR is not set use the default SDK path. This will be the case
-  # when DEPOT_TOOLS_WIN_TOOLCHAIN=0 and vcvarsall.bat has not been run.
-  win_sdk_dir = os.path.normpath(
-      os.environ.get('WINDOWSSDKDIR',
-                     'C:\\Program Files (x86)\\Windows Kits\\10'))
+  win_sdk_dir = os.path.normpath(os.environ['WindowsSdkDir'])
   ucrt_dll_dirs = os.path.join(win_sdk_dir, r'Redist\ucrt\DLLs', target_cpu)
   ucrt_files = glob.glob(os.path.join(ucrt_dll_dirs, 'api-ms-win-*.dll'))
   assert len(ucrt_files) > 0
   for ucrt_src_file in ucrt_files:
     file_part = os.path.basename(ucrt_src_file)
     ucrt_dst_file = os.path.join(target_dir, file_part)
     _CopyRuntimeImpl(ucrt_dst_file, ucrt_src_file, False)
   _CopyRuntimeImpl(os.path.join(target_dir, 'ucrtbase' + suffix),
                     os.path.join(source_dir, 'ucrtbase' + suffix))
 
 
 def _CopyRuntime(target_dir, source_dir, target_cpu, debug):
   """Copy the VS runtime DLLs, only if the target doesn't exist, but the target
   directory does exist. Handles VS 2013, VS 2015, and VS 2017."""
   suffix = "d.dll" if debug else ".dll"
+  dll_pattern = "%s" + _SdkFileSuffix() + suffix
   if GetVisualStudioVersion() in ['2015', '2017']:
     # VS 2017 uses the same CRT DLLs as VS 2015.
-    _CopyUCRTRuntime(target_dir, source_dir, target_cpu, '%s140' + suffix,
-                     suffix)
+    _CopyUCRTRuntime(target_dir, source_dir, target_cpu, dll_pattern, suffix)
   else:
-    _CopyRuntime2013(target_dir, source_dir, 'msvc%s120' + suffix)
+    _CopyRuntime2013(target_dir, source_dir, 'msvc' + dll_pattern)

[brucedawson, 2017/03/27 23:23:52]

You'll need to rebase as the 2013 support was just removed. Sorry :-(

 
   # Copy the PGO runtime library to the release directories.
   if not debug and os.environ.get('GYP_MSVS_OVERRIDE_PATH'):
-    pgo_x86_runtime_dir = os.path.join(os.environ.get('GYP_MSVS_OVERRIDE_PATH'),
-                                        'VC', 'bin')
-    pgo_x64_runtime_dir = os.path.join(pgo_x86_runtime_dir, 'amd64')
-    pgo_runtime_dll = 'pgort' + _VersionNumber() + '.dll'
-    if target_cpu == "x86":
-      source_x86 = os.path.join(pgo_x86_runtime_dir, pgo_runtime_dll)
-      if os.path.exists(source_x86):
-        _CopyRuntimeImpl(os.path.join(target_dir, pgo_runtime_dll), source_x86)
-    elif target_cpu == "x64":
-      source_x64 = os.path.join(pgo_x64_runtime_dir, pgo_runtime_dll)
-      if os.path.exists(source_x64):
-        _CopyRuntimeImpl(os.path.join(target_dir, pgo_runtime_dll),
-                          source_x64)
+    pgo_runtime_dll = 'pgort' + _SdkFileSuffix() + '.dll'
+    paths = subprocess.check_output(['where.exe', pgo_runtime_dll])\
+      .strip()\
+      .split('\n')
+    source = paths[-1].strip()
+    if os.path.exists(source):
+      _CopyRuntimeImpl(os.path.join(target_dir, pgo_runtime_dll), source)
     else:
-      raise NotImplementedError("Unexpected target_cpu value:" + target_cpu)
+      raise NotImplementedError("could not find " + pgo_runtime_dll)
 
 
 def CopyVsRuntimeDlls(output_dir, runtime_dirs):
   """Copies the VS runtime DLLs from the given |runtime_dirs| to the output
   directory so that even if not system-installed, built binaries are likely to
   be able to run.
 
   This needs to be run after gyp has been run so that the expected target
   output directories are already created.
 
@@ skipping 103 matching lines @@
     force = True
 
   depot_tools_win_toolchain = \
       bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
   if ((sys.platform in ('win32', 'cygwin') or force) and
         depot_tools_win_toolchain):
     import find_depot_tools
     depot_tools_path = find_depot_tools.add_depot_tools_to_path()
     # Necessary so that get_toolchain_if_necessary.py will put the VS toolkit
     # in the correct directory.
-    os.environ['GYP_MSVS_VERSION'] = GetVisualStudioVersion()
+    GetVisualStudioVersion()
     get_toolchain_args = [
         sys.executable,
         os.path.join(depot_tools_path,
                     'win_toolchain',
                     'get_toolchain_if_necessary.py'),
         '--output-json', json_data_file,
       ] + _GetDesiredVsToolchainHashes()
     if force:
       get_toolchain_args.append('--force')
     subprocess.check_call(get_toolchain_args)
 
   return 0
 
 
 def NormalizePath(path):
   while path.endswith("\\"):
     path = path[:-1]
   return path
 
 
 def SetEnvironmentAndGetSDKDir():
   """Gets location information about the current sdk (must have been
   previously updated by 'update'). This is used for the GN build."""
   runtime_dll_dirs = SetEnvironmentAndGetRuntimeDllDirs()
-
-  # If WINDOWSSDKDIR is not set, search the default SDK path and set it.
-  if not 'WINDOWSSDKDIR' in os.environ:
-    default_sdk_path = 'C:\\Program Files (x86)\\Windows Kits\\10'
-    if os.path.isdir(default_sdk_path):
-      os.environ['WINDOWSSDKDIR'] = default_sdk_path
-
-  return NormalizePath(os.environ['WINDOWSSDKDIR'])
+  return NormalizePath(os.environ['WindowsSdkDir'])
 
 
 def GetToolchainDir():
   """Gets location information about the current toolchain (must have been
   previously updated by 'update'). This is used for the GN build."""
   runtime_dll_dirs = SetEnvironmentAndGetRuntimeDllDirs()
   win_sdk_dir = SetEnvironmentAndGetSDKDir()
 
   print '''vs_path = "%s"
 sdk_path = "%s"
@@ skipping 15 matching lines @@
       'copy_dlls': CopyDlls,
   }
   if len(sys.argv) < 2 or sys.argv[1] not in commands:
     print >>sys.stderr, 'Expected one of: %s' % ', '.join(commands)
     return 1
   return commands[sys.argv[1]](*sys.argv[2:])
 
 
 if __name__ == '__main__':
   sys.exit(main())