Refactor VS toolchain code in gyp_chromium

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
+import vs_toolchain
 
 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 300 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 DownloadVsToolChain():
-  """Download the Visual Studio toolchain on Windows.
-
-  If on Windows, request that depot_tools install/update the automatic
-  toolchain, and then use it (unless opted-out) and return a tuple containing
-  the x64 and x86 paths. Otherwise return None.
-  """
-  vs2013_runtime_dll_dirs = None
-  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()
-    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']
-    # TODO(scottmg): The order unfortunately matters in these. They should be
-    # split into separate keys for x86 and x64. (See CopyVsRuntimeDlls call
-    # below). http://crbug.com/345992
-    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'))
-  return vs2013_runtime_dll_dirs
-
-
-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'))
-
-  def copy_runtime(target_dir, source_dir, dll_pattern):
-    """Copy both the msvcr and msvcp runtime DLLs, only if the target doesn't
-    exist, but the target directory does exist."""
-    for which in ('p', 'r'):
-      dll = dll_pattern % which
-      target = os.path.join(target_dir, dll)
-      source = os.path.join(source_dir, dll)
-      # If gyp generated to that output dir, and the runtime isn't already
-      # there, then copy it over.
-      if (os.path.isdir(target_dir) and
-          (not os.path.isfile(target) or
-            os.stat(target).st_mtime != os.stat(source).st_mtime)):
-        print 'Copying %s to %s...' % (source, target)
-        if os.path.exists(target):
-          os.unlink(target)
-        shutil.copy2(source, target)
-
-  x86, x64 = runtime_dirs
-  out_debug = os.path.join(output_dir, 'Debug')
-  out_debug_nacl64 = os.path.join(output_dir, 'Debug', 'x64')
-  out_release = os.path.join(output_dir, 'Release')
-  out_release_nacl64 = os.path.join(output_dir, 'Release', 'x64')
-  out_debug_x64 = os.path.join(output_dir, 'Debug_x64')
-  out_release_x64 = os.path.join(output_dir, 'Release_x64')
-
-  if os.path.exists(out_debug) and not os.path.exists(out_debug_nacl64):
-    os.makedirs(out_debug_nacl64)
-  if os.path.exists(out_release) and not os.path.exists(out_release_nacl64):
-    os.makedirs(out_release_nacl64)
-  copy_runtime(out_debug,          x86, 'msvc%s120d.dll')
-  copy_runtime(out_release,        x86, 'msvc%s120.dll')
-  copy_runtime(out_debug_x64,      x64, 'msvc%s120d.dll')
-  copy_runtime(out_release_x64,    x64, 'msvc%s120.dll')
-  copy_runtime(out_debug_nacl64,   x64, 'msvc%s120d.dll')
-  copy_runtime(out_release_nacl64, x64, 'msvc%s120.dll')
-
-
 if __name__ == '__main__':
   args = sys.argv[1:]
 
   if int(os.environ.get('GYP_CHROMIUM_NO_ACTION', 0)):
     print 'Skipping gyp_chromium due to GYP_CHROMIUM_NO_ACTION env var.'
     sys.exit(0)
 
   # Use the Psyco JIT if available.
   if psyco:
     psyco.profile()
@@ skipping 60 matching lines @@
   # . -f / --format has precedence over the env var, no need to check for it
   # . 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', 'win', 'freebsd')) 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'
 
-  vs2013_runtime_dll_dirs = DownloadVsToolChain()
+  vs2013_runtime_dll_dirs = vs_toolchain.DownloadVsToolchain()
 
   # 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 21 matching lines @@
 
   # Check for landmines (reasons to clobber the build). This must be run here,
   # rather than a separate runhooks step so that any environment modifications
   # 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:
     x64_runtime, x86_runtime = vs2013_runtime_dll_dirs
-    CopyVsRuntimeDlls(os.path.join(chrome_src, GetOutputDirectory()),
-                      (x86_runtime, x64_runtime))
+    vs_toolchain.CopyVsRuntimeDlls(
+        os.path.join(chrome_src, GetOutputDirectory()),
+        (x86_runtime, x64_runtime))
 
   sys.exit(gyp_rc)