win toolchain: Load env from json file, not .cmd file.

build/toolchain/win/setup_toolchain.py

 # Copyright (c) 2013 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.
 #
 # Copies the given "win tool" (which the toolchain uses to wrap compiler
 # invocations) and the environment blocks for the 32-bit and 64-bit builds on
 # Windows to the build directory.
 #
 # The arguments are the visual studio install location and the location of the
 # win tool. The script assumes that the root build directory is the current dir
 # and the files will be written to the current directory.
 
 import errno
+import json
 import os
 import re
 import subprocess
 import sys
 
 SCRIPT_DIR = os.path.dirname(__file__)
 
 def _ExtractImportantEnvironment(output_of_set):
   """Extracts environment variables required for the toolchain to run from
   a textual dump output by the cmd.exe 'set' command."""
@@ skipping 36 matching lines @@
   """Return path to the GYP_MSVS_VERSION of Visual Studio.
   """
 
   # Use the code in build/vs_toolchain.py to avoid duplicating code.
   chromium_dir = os.path.abspath(os.path.join(SCRIPT_DIR, '..', '..', '..'))
   sys.path.append(os.path.join(chromium_dir, 'build'))
   import vs_toolchain
   return vs_toolchain.DetectVisualStudioPath()
 
 
-def _SetupScript(target_cpu, sdk_dir):
-  """Returns a command (with arguments) to be used to set up the
-  environment."""
-  # Check if we are running in the SDK command line environment and use
-  # the setup script from the SDK if so. |target_cpu| should be either
-  # 'x86' or 'x64'.
-  assert target_cpu in ('x86', 'x64')
-  if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', 1))) and sdk_dir:
-    return [os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.Cmd')),
-            '/' + target_cpu]
-  else:
-    if 'GYP_MSVS_OVERRIDE_PATH' not in os.environ:
-      os.environ['GYP_MSVS_OVERRIDE_PATH'] = _DetectVisualStudioPath()
-    # We only support x64-hosted tools.
-    return [os.path.normpath(os.path.join(os.environ['GYP_MSVS_OVERRIDE_PATH'],
-                                          'VC/vcvarsall.bat')),
-            'amd64_x86' if target_cpu == 'x86' else 'amd64']
-
-
-def _LoadToolchainEnv(cpu, win_sdk_path):
-  """Returns a dictionary with environment variables that must be set while
-  running binaries from the toolchain (e.g. INCLUDE and PATH for cl.exe)."""
-  args = _SetupScript(cpu, win_sdk_path)
+def _LoadEnvFromBat(args):
+  """Given a bat command, runs it and returns env vars set by it."""
+  args = args[:]
   args.extend(('&&', 'set'))
   popen = subprocess.Popen(
       args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
   variables, _ = popen.communicate()
   if popen.returncode != 0:
     raise Exception('"%s" failed with error %d' % (args, popen.returncode))
+  return variables
+
+
+def _LoadToolchainEnv(cpu, sdk_dir):
+  """Returns a dictionary with environment variables that must be set while
+  running binaries from the toolchain (e.g. INCLUDE and PATH for cl.exe)."""
+  # Check if we are running in the SDK command line environment and use
+  # the setup script from the SDK if so. |cpu| should be either
+  # 'x86' or 'x64'.
+  assert cpu in ('x86', 'x64')
+  if bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', 1))) and sdk_dir:
+    # Load environment from json file.
+    env = os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.%s.json' % cpu))
+    env = json.load(open(env))['env']
+    for k in env:
+      entries = [os.path.join(*([os.path.join(sdk_dir, 'bin')] + e))
+                 for e in env[k]]
+      env[k] = os.pathsep.join(entries)
+    # PATH is a bit of a special case, it's in addition to the current PATH.
+    env['PATH'] = env['PATH'] + os.pathsep + os.environ['PATH']
+    # Augment with the current env to pick up TEMP and friends.
+    for k in os.environ:
+      if k not in env:
+        env[k] = os.environ[k]
+
+    varlines = []
+    for k in sorted(env.keys()):
+      varlines.append('%s=%s' % (str(k), str(env[k])))
+    variables = '\n'.join(varlines)
+
+    # Check that the json file contained the same environment as the .cmd file.
+    script = os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.cmd'))
+    assert _ExtractImportantEnvironment(variables) == \
+           _ExtractImportantEnvironment(_LoadEnvFromBat([script, '/' + cpu]))
+  else:
+    if 'GYP_MSVS_OVERRIDE_PATH' not in os.environ:
+      os.environ['GYP_MSVS_OVERRIDE_PATH'] = _DetectVisualStudioPath()
+    # We only support x64-hosted tools.
+    args = [os.path.normpath(os.path.join(os.environ['GYP_MSVS_OVERRIDE_PATH'],
+                                          'VC/vcvarsall.bat')),
+            'amd64_x86' if cpu == 'x86' else 'amd64']
+    variables = _LoadEnvFromBat(args)
   return _ExtractImportantEnvironment(variables)
 
 
 def _FormatAsEnvironmentBlock(envvar_dict):
   """Format as an 'environment block' directly suitable for CreateProcess.
   Briefly this is a list of key=value\0, terminated by an additional \0. See
   CreateProcess documentation for more details."""
   block = ''
   nul = '\0'
   for key, value in envvar_dict.iteritems():
@@ skipping 71 matching lines @@
     env_block = _FormatAsEnvironmentBlock(env)
     with open('environment.winrt_' + cpu, 'wb') as f:
         f.write(env_block)
 
   assert vc_bin_dir
   print 'vc_bin_dir = "%s"' % vc_bin_dir
 
 
 if __name__ == '__main__':
   main()