Move control of updating toolchain into src/

build/gyp_chromium

 #!/usr/bin/env python
 
 # Copyright (c) 2012 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.
 
 # This script is wrapper for Chromium that adds some support for how GYP
 # is invoked by Chromium beyond what can be done in the gclient hooks.
 
 import glob
 import gyp_helper
+import json
 import os
 import pipes
 import shlex
 import shutil
 import subprocess
 import string
 import sys
+import tempfile
 
 script_dir = os.path.dirname(os.path.realpath(__file__))
 chrome_src = os.path.abspath(os.path.join(script_dir, os.pardir))
 
 sys.path.insert(0, os.path.join(chrome_src, 'tools', 'gyp', 'pylib'))
 import gyp
 
 # Assume this file is in a one-level-deep subdirectory of the source root.
 SRC_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
@@ skipping 294 matching lines @@
   # Need to pass both the source root (the bots don't run this command from
   # within the source tree) as well as set the is_gyp value so the BUILD files
   # to know they're being run under GYP.
   args = [gnpath, 'gyp', '-q',
           '--root=' + chrome_src,
           '--args=' + GetArgsStringForGN(vars_dict),
           '--output=//' + GetOutputDirectory() + '/gn_build/']
   return subprocess.call(args) == 0
 
 
+def GetDesiredVsToolchainHashes():
+  """Load a list of SHA1s corresponding to the toolchains that we want installed
+  to build with."""
+  sha1path = os.path.join(script_dir, 'toolchain_vs2013.hash')
+  with open(sha1path, 'rb') as f:
+    return f.read().strip().splitlines()
+
+
 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.
   """
   assert sys.platform.startswith(('win32', 'cygwin'))
 
@@ skipping 88 matching lines @@
   # . set the env var only if it hasn't been set yet
   # . chromium.gyp_env has been applied to os.environ at this point already
   if sys.platform.startswith('linux') and not os.environ.get('GYP_GENERATORS'):
     os.environ['GYP_GENERATORS'] = 'ninja'
   if sys.platform.startswith('win') and not os.environ.get('GYP_GENERATORS'):
     os.environ['GYP_GENERATORS'] = 'ninja'
   elif sys.platform == 'darwin' and not os.environ.get('GYP_GENERATORS') and \
       not 'OS=ios' in os.environ.get('GYP_DEFINES', []):
     os.environ['GYP_GENERATORS'] = 'ninja'
 
-  # If on windows, and the automatic toolchain has been installed by
-  # depot_tools, then use it.
+  # If on Windows, request that depot_tools install/update the automatic
+  # toolchain, and then use it (unless opted-out).
   vs2013_runtime_dll_dirs = None
-  # If MSVS_VERSION is explicitly specified to be something other than 2013,
-  # don't use the automatic toolchain, as it currently only supports VS2013.
-  msvs_version = os.environ.get('GYP_MSVS_VERSION', '2013')
-  if sys.platform in ('win32', 'cygwin') and msvs_version.startswith('2013'):
+  depot_tools_win_toolchain = \
+      bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
+  if sys.platform in ('win32', 'cygwin') and depot_tools_win_toolchain:
     import find_depot_tools
     depot_tools_path = find_depot_tools.add_depot_tools_to_path()
-    toolchain = os.path.normpath(os.path.join(
-        depot_tools_path, 'win_toolchain', 'vs2013_files'))
-    version_file = os.path.join(toolchain, '.version')
-    if os.path.isdir(toolchain) and os.path.isfile(version_file):
-      os.environ['GYP_MSVS_OVERRIDE_PATH'] = toolchain
-      with open(version_file, 'r') as f:
-        version_is_pro = f.read().strip() == 'pro'
-      vs2013_runtime_dll_dirs = (os.path.join(toolchain, 'sys32'),
-                                 os.path.join(toolchain, 'sys64'))
-      os.environ['GYP_MSVS_VERSION'] = '2013' if version_is_pro else '2013e'
-      # 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 other
-      # values there.
-      gyp_defines_dict = gyp.NameValueListToDict(gyp.ShlexEnv('GYP_DEFINES'))
-      win8sdk = os.path.join(toolchain, 'win8sdk')
-      wdk = os.path.join(toolchain, 'wdk')
-      gyp_defines_dict['windows_sdk_path'] = win8sdk
-      os.environ['WINDOWSSDKDIR'] = win8sdk
-      os.environ['WDK_DIR'] = wdk
-      os.environ['GYP_DEFINES'] = ' '.join('%s=%s' % (k, pipes.quote(str(v)))
-          for k, v in gyp_defines_dict.iteritems())
-      # Include the VS runtime in the PATH in case it's not machine-installed.
-      runtime_path = ';'.join(os.path.normpath(os.path.join(toolchain, s))
-                              for s in ('sys64', 'sys32'))
-      os.environ['PATH'] = runtime_path + ';' + os.environ['PATH']
-      print('Using automatic toolchain in %s (%s edition).' % (
-                toolchain, 'Pro' if version_is_pro else 'Express'))
+    temp_handle, data_file = tempfile.mkstemp(suffix='.json')
+    os.close(temp_handle)
+    get_toolchain_args = [
+        sys.executable,
+        os.path.join(depot_tools_path,
+                    'win_toolchain',
+                    'get_toolchain_if_necessary.py'),
+        '--output-json', data_file,
+      ] + GetDesiredVsToolchainHashes()
+    subprocess.check_call(get_toolchain_args)
+
+    with open(data_file, 'r') as tempf:
+      toolchain_data = json.load(tempf)
+    os.unlink(data_file)
+
+    toolchain = toolchain_data['path']
+    version = toolchain_data['version']
+    version_is_pro = version[-1] != 'e'
+    win8sdk = toolchain_data['win8sdk']
+    wdk = toolchain_data['wdk']
+    vs2013_runtime_dll_dirs = toolchain_data['runtime_dirs']
+
+    os.environ['GYP_MSVS_OVERRIDE_PATH'] = toolchain
+    os.environ['GYP_MSVS_VERSION'] = version
+    # 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'] = win8sdk
+    os.environ['GYP_DEFINES'] = ' '.join('%s=%s' % (k, pipes.quote(str(v)))
+        for k, v in gyp_defines_dict.iteritems())
+    os.environ['WINDOWSSDKDIR'] = win8sdk
+    os.environ['WDK_DIR'] = wdk
+    # Include the VS runtime in the PATH in case it's not machine-installed.
+    runtime_path = ';'.join(vs2013_runtime_dll_dirs)
+    os.environ['PATH'] = runtime_path + ';' + os.environ['PATH']
+    print('Using automatic toolchain in %s (%s edition).' % (
+              toolchain, 'Pro' if version_is_pro else 'Express'))
 
   # If CHROMIUM_GYP_SYNTAX_CHECK is set to 1, it will invoke gyp with --check
   # to enfore syntax checking.
   syntax_check = os.environ.get('CHROMIUM_GYP_SYNTAX_CHECK')
   if syntax_check and int(syntax_check):
     args.append('--check')
 
   supplemental_includes = GetSupplementalFiles()
   gn_vars_dict = GetGypVarsForGN(supplemental_includes)
 
@@ skipping 23 matching lines @@
   # from above are picked up.
   print 'Running build/landmines.py...'
   subprocess.check_call(
       [sys.executable, os.path.join(script_dir, 'landmines.py')])
 
   if vs2013_runtime_dll_dirs:
     CopyVsRuntimeDlls(os.path.join(chrome_src, GetOutputDirectory()),
                       vs2013_runtime_dll_dirs)
 
   sys.exit(gyp_rc)