Ensure GYP_MSVS_VERSION is set for GN build.

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 json
 import os
 import pipes
 import shutil
 import subprocess
@@ skipping 80 matching lines @@
     return None
 
 
 def _RegistryGetValue(key, value):
   try:
     return _RegistryGetValueUsingWinReg(key, value)
   except ImportError:
     raise Exception('The python library _winreg not found.')
 
 
+def GetVisualStudioVersion():
+  """Return GYP_MSVS_VERSION of Visual Studio, default to 2013 for now.
+  """
+

[scottmg, 2016/01/12 20:56:44]

Remove blank line.

+  return os.environ.get('GYP_MSVS_VERSION', '2013')
+
+
 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.
 
   # Default to Visual Studio 2013 for now.

[scottmg, 2016/01/12 20:56:44]

Remove this comment, it's in the function body now.

-  version_as_year = os.environ.get('GYP_MSVS_VERSION', '2013')
+  version_as_year = GetVisualStudioVersion()
   year_to_version = {
       '2013': '12.0',
       '2015': '14.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]
   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
 
   raise Exception(('Visual Studio Version %s (from GYP_MSVS_VERSION)'
                    ' not found.') % (version_as_year))
 
 
 def _VersionNumber():
   """Gets the standard version number ('120', '140', etc.) based on
   GYP_MSVS_VERSION."""
-  if os.environ['GYP_MSVS_VERSION'] == '2013':
+  vs_version = GetVisualStudioVersion()
+  if vs_version == '2013':
     return '120'
-  elif os.environ['GYP_MSVS_VERSION'] == '2015':
+  elif vs_version == '2015':
     return '140'
   else:
     raise ValueError('Unexpected GYP_MSVS_VERSION')
 
 
 def _CopyRuntimeImpl(target, source):
   """Copy |source| to |target| if it doesn't already exist or if it
   needs to be updated.
   """
   if (os.path.isdir(os.path.dirname(target)) and
@@ skipping 22 matching lines @@
     dll = dll_pattern % file_part
     target = os.path.join(target_dir, dll)
     source = os.path.join(source_dir, dll)
     _CopyRuntimeImpl(target, source)
 
 
 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 and VS 2015."""
   suffix = "d.dll" if debug else ".dll"
-  if os.environ.get('GYP_MSVS_VERSION') == '2015':
+  if GetVisualStudioVersion() == '2015':
     _CopyRuntime2015(target_dir, source_dir, '%s140' + suffix)
   else:
     _CopyRuntime2013(target_dir, source_dir, 'msvc%s120' + suffix)
 
   # 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'
@@ skipping 58 matching lines @@
   x64_runtime, x86_runtime = vs_runtime_dll_dirs
   runtime_dir = x64_runtime if target_cpu == 'x64' else x86_runtime
   _CopyRuntime(target_dir, runtime_dir, target_cpu, debug=False)
   if configuration == 'Debug':
     _CopyRuntime(target_dir, runtime_dir, target_cpu, debug=True)
 
 
 def _GetDesiredVsToolchainHashes():
   """Load a list of SHA1s corresponding to the toolchains that we want installed
   to build with."""
-  if os.environ.get('GYP_MSVS_VERSION') == '2015':
+  if GetVisualStudioVersion() == '2015':
     return ['17c7ddb3595be5c6b9c98b6f930adad7e4456671'] # Update 1
   else:
     # Default to VS2013.
     return ['9ff97c632ae1fee0c98bcd53e71770eb3a0d8deb']
 
 
 def Update(force=False):
   """Requests an update of the toolchain to the specific hashes we have at
   this revision. The update outputs a .json of the various configuration
   information required to pass to gyp which we use in |GetToolchainDir()|.
@@ skipping 36 matching lines @@
       os.environ['WINDOWSSDKDIR'] = default_sdk_path
 
   print '''vs_path = "%s"
 sdk_path = "%s"
 vs_version = "%s"
 wdk_dir = "%s"
 runtime_dirs = "%s"
 ''' % (
       os.environ['GYP_MSVS_OVERRIDE_PATH'],
       os.environ['WINDOWSSDKDIR'],
-      os.environ['GYP_MSVS_VERSION'],
+      GetVisualStudioVersion(),
       os.environ.get('WDK_DIR', ''),
       ';'.join(runtime_dll_dirs or ['None']))
 
 
 def main():
   commands = {
       'update': Update,
       'get_toolchain_dir': GetToolchainDir,
       '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())