RubyGems - libv8 - Versions diffs - 4.5.95.5 → 5.0.71.48.0beta2 - Mend

libv8 4.5.95.5 → 5.0.71.48.0beta2

Files changed (332) hide show

data/vendor/depot_tools/git-crup DELETED

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-# 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.
-TOPLEVEL=$(git rev-parse --show-toplevel)
-TOPPERLEVEL=$(dirname $TOPLEVEL)
-cat <<EOF
-Sorry `whoami`, but the git-submodule flow has been deprecated in order to
-simplify the plethora of SCM choices, and to pave the way towards a git-only
-chromium development flow.
-Please consult https://code.google.com/p/chromium/wiki/UsingGitSubmodules#Convert_from_submodules_to_gclient
-for instructions on how to convert your submodule checkout to gclient.
-The simplest chromium and/or blink instructions follow for convenience.
-1. Make sure the parent directory of this checkout is empty, besides this repo:
-$ ls $TOPPERLEVEL
-EOF
-ls "$TOPPERLEVEL"
-if [[ "$(ls "$TOPPERLEVEL")" != 'src' ]]
-then
-  echo Please move this repo to its own directory before continuing!!!
-fi
-echo
-cat <<EOF
-2. Please add a .gclient file to $TOPPERLEVEL/.gclient of the form:
-# ======== .gclient begins =========
-solutions = [{
-  'name': '$(basename "$TOPLEVEL")',
-  'url': 'https://chromium.googlesource.com/chromium/src.git',
-  'managed': False,
-  'deps_file': '.DEPS.git',
-  # Uncomment the following if you're doing blink development
-  # 'custom_vars': {'webkit_revision': ''},
-}]
-# ======== .gclient ends =========
-3. Run \`gclient sync\` to synchronize dependencies in your checkout instead of $(basename "$0")!
-EOF
-exit 1

data/vendor/depot_tools/python_git_runner.sh DELETED

@@ -1,36 +0,0 @@
-# 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.
-## This file is designed to be sourced from a bash script whose name takes the
-## form 'git-sub-command'. This script will then instead invoke
-## '[depot_tools]/git_sub_command.py' correctly under mingw as well
-## as posix-ey systems, passing along all other command line flags.
-## Example:
-## echo ". python_git_runner.sh" > git-foo-command
-## ./git-foo-command  #=> runs `python git_foo_command.py`
-## Constants
-PYTHONDONTWRITEBYTECODE=1
-## "Input parameters".
-# If set before the script is sourced, then we'll use the pre-set values.
-#
-# SCRIPT defaults to the basename of $0, with dashes replaced with underscores
-if [[ $OSTYPE = msys ]]
-then
-  DEPOT_TOOLS="${0%\\*}"
-  BASENAME="${0##*\\}"
-else
-  DEPOT_TOOLS="${0%/*}"
-  BASENAME="${0##*/}"
-fi
-SCRIPT="${SCRIPT-${BASENAME//-/_}.py}"
-if [[ -e "$DEPOT_TOOLS/python.bat" && $OSTYPE = msys ]]; then
-  cmd.exe //c "$DEPOT_TOOLS\\python.bat" "$DEPOT_TOOLS\\$SCRIPT" "$@"
-else
-  exec "$DEPOT_TOOLS/$SCRIPT" "$@"
-fi

data/vendor/depot_tools/recipes/blink.py DELETED

@@ -1,59 +0,0 @@
-# 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.
-import json
-import sys
-import recipe_util  # pylint: disable=F0401
-# This class doesn't need an __init__ method, so we disable the warning
-# pylint: disable=W0232
-class Blink(recipe_util.Recipe):
-  """Basic Recipe alias for Blink -> Chromium."""
-  @staticmethod
-  def fetch_spec(props):
-    chromium_url = 'https://chromium.googlesource.com/chromium/src.git'
-    chromium_solution = {'name': 'src',
-                         'url': chromium_url,
-                         'deps_file': 'DEPS',
-                         'managed': False,
-                         'custom_deps': {
-                             'src/third_party/WebKit': None,
-                         },
-    }
-    blink_url = 'https://chromium.googlesource.com/chromium/blink.git'
-    blink_solution = {'name': 'src/third_party/WebKit',
-                      'url': blink_url,
-                      'deps_file': '.DEPS.git',
-                      'managed': False,
-                      'custom_deps': {},
-    }
-    spec = {
-      'solutions': [chromium_solution, blink_solution],
-      'auto': True,
-    }
-    if props.get('target_os'):
-      spec['target_os'] = props['target_os'].split(',')
-    if props.get('target_os_only'):
-      spec['target_os_only'] = props['target_os_only']
-    toolchain_hook = [sys.executable, 'src/build/confirm_toolchain.py']
-    spec['fetch_hooks'] = [toolchain_hook]
-    return {
-      'type': 'gclient_git_svn',
-      'gclient_git_svn_spec': spec,
-    }
-  @staticmethod
-  def expected_root(_props):
-    return 'src/third_party/WebKit'
-def main(argv=None):
-  return Blink().handle_args(argv)
-if __name__ == '__main__':
-  sys.exit(main(sys.argv))

data/vendor/depot_tools/third_party/cq_client/test/validate_config_test.py DELETED

@@ -1,52 +0,0 @@
-# Copyright 2015 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.
-"""Unit tests for tools/validate_config.py."""
-import mock
-import os
-import unittest
-from cq_client import cq_pb2
-from cq_client import validate_config
-TEST_DIR = os.path.dirname(os.path.abspath(__file__))
-class TestValidateConfig(unittest.TestCase):
-  def test_is_valid(self):
-    with open(os.path.join(TEST_DIR, 'cq_example.cfg'), 'r') as test_config:
-      self.assertTrue(validate_config.IsValid(test_config.read()))
-  def test_has_field(self):
-    config = cq_pb2.Config()
-    self.assertFalse(validate_config._HasField(config, 'version'))
-    config.version = 1
-    self.assertTrue(validate_config._HasField(config, 'version'))
-    self.assertFalse(validate_config._HasField(
-        config, 'rietveld.project_bases'))
-    config.rietveld.project_bases.append('foo://bar')
-    self.assertTrue(validate_config._HasField(
-        config, 'rietveld.project_bases'))
-    self.assertFalse(validate_config._HasField(
-        config, 'verifiers.try_job.buckets'))
-    self.assertFalse(validate_config._HasField(
-        config, 'verifiers.try_job.buckets.name'))
-    bucket = config.verifiers.try_job.buckets.add()
-    bucket.name = 'tryserver.chromium.linux'
-    self.assertTrue(validate_config._HasField(
-        config, 'verifiers.try_job.buckets'))
-    self.assertTrue(validate_config._HasField(
-        config, 'verifiers.try_job.buckets.name'))
-    config.verifiers.try_job.buckets.add()
-    self.assertFalse(validate_config._HasField(
-        config, 'verifiers.try_job.buckets.name'))

data/vendor/depot_tools/third_party/cq_client/validate_config.py DELETED

@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2015 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.
-"""CQ config validation library."""
-import argparse
-from google import protobuf
-import logging
-import re
-import sys
-from cq_client import cq_pb2
-REQUIRED_FIELDS = [
-  'version',
-  'rietveld',
-  'rietveld.url',
-  'verifiers',
-  'cq_name',
-]
-LEGACY_FIELDS = [
-  'svn_repo_url',
-  'server_hooks_missing',
-  'verifiers_with_patch',
-]
-EMAIL_REGEXP = '^[^@]+@[^@]+\.[^@]+$'
-def _HasField(message, field_path):
-  """Checks that at least one field with given path exist in the proto message.
-  This function correctly handles repeated fields and will make sure that each
-  repeated field will have required sub-path, e.g. if 'abc' is a repeated field
-  and field_path is 'abc.def', then the function will only return True when each
-  entry for 'abc' will contain at least one value for 'def'.
-  Args:
-    message (google.protobuf.message.Message): Protocol Buffer message to check.
-    field_path (string): Path to the target field separated with ".".
-  Return:
-    True if at least one such field is explicitly set in the message.
-  """
-  path_parts = field_path.split('.', 1)
-  field_name = path_parts[0]
-  sub_path = path_parts[1] if len(path_parts) == 2 else None
-  field_labels = {fd.name: fd.label for fd in message.DESCRIPTOR.fields}
-  repeated_field = (field_labels[field_name] ==
-                    protobuf.descriptor.FieldDescriptor.LABEL_REPEATED)
-  if sub_path:
-    field = getattr(message, field_name)
-    if repeated_field:
-      if not field:
-        return False
-      return all(_HasField(entry, sub_path) for entry in field)
-    else:
-      return _HasField(field, sub_path)
-  else:
-    if repeated_field:
-      return len(getattr(message, field_name)) > 0
-    else:
-      return message.HasField(field_name)
-def IsValid(cq_config):
-  """Validates a CQ config and prints errors/warnings to the screen.
-  Args:
-    cq_config (string): Unparsed text format of the CQ config proto.
-  Returns:
-    True if the config is valid.
-  """
-  try:
-    config = cq_pb2.Config()
-    protobuf.text_format.Merge(cq_config, config)
-  except protobuf.text_format.ParseError as e:
-    logging.error('Failed to parse config as protobuf:\n%s', e)
-    return False
-  for fname in REQUIRED_FIELDS:
-    if not _HasField(config, fname):
-      logging.error('%s is a required field', fname)
-      return False
-  for fname in LEGACY_FIELDS:
-    if _HasField(config, fname):
-      logging.warn('%s is a legacy field', fname)
-  for base in config.rietveld.project_bases:
-    try:
-      re.compile(base)
-    except re.error:
-      logging.error('failed to parse "%s" in project_bases as a regexp', base)
-      return False
-  # TODO(sergiyb): For each field, check valid values depending on its
-  # semantics, e.g. email addresses, regular expressions etc.
-  return True

data/vendor/depot_tools/win_toolchain/toolchain2013.py DELETED

@@ -1,494 +0,0 @@
-#!/usr/bin/env python
-# Copyright 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.
-"""Extracts a Windows VS2013 toolchain from various downloadable pieces."""
-import ctypes
-import json
-import optparse
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import urllib2
-BASEDIR = os.path.dirname(os.path.abspath(__file__))
-WDK_ISO_URL = (
-    'http://download.microsoft.com/download/'
-    '4/A/2/4A25C7D5-EFBE-4182-B6A9-AE6850409A78/GRMWDK_EN_7600_1.ISO')
-g_temp_dirs = []
-sys.path.append(os.path.join(BASEDIR, '..'))
-import download_from_google_storage
-def GetLongPathName(path):
-  """Converts any 8dot3 names in the path to the full name."""
-  buf = ctypes.create_unicode_buffer(260)
-  size = ctypes.windll.kernel32.GetLongPathNameW(unicode(path), buf, 260)
-  if (size > 260):
-    sys.exit('Long form of path longer than 260 chars: %s' % path)
-  return buf.value
-def RunOrDie(command):
-  subprocess.check_call(command, shell=True)
-class ScopedSubstTempDir(object):
-  """Creates a |TempDir()| and subst's a drive to the path.
-  This is done to avoid exceedingly long names in some .msi packages which
-  fail to extract because they exceed _MAX_PATH. Only the "subst" part of this
-  is scoped, not the temp dir, which is left for use and cleanup by the
-  caller.
-  """
-  DefineDosDevice = ctypes.windll.kernel32.DefineDosDeviceW
-  DefineDosDevice.argtypes = [ctypes.c_int, ctypes.c_wchar_p, ctypes.c_wchar_p]
-  DDD_NO_BROADCAST_SYSTEM = 0x08
-  DDD_REMOVE_DEFINITION = 0x02
-  def __init__(self):
-    self.real_path = TempDir()
-    self.subst_drive = None
-  def __enter__(self):
-    """Tries to find a subst that we can use for the temporary directory, and
-    aborts on failure."""
-    for drive in range(ord('Z'), ord('A') - 1, -1):
-      candidate = '%c:' % drive
-      if self.DefineDosDevice(
-          self.DDD_NO_BROADCAST_SYSTEM, candidate, self.real_path) != 0:
-        self.subst_drive = candidate
-        return self
-    raise RuntimeError('Unable to find a subst path')
-  def __exit__(self, typ, value, traceback):
-    if self.subst_drive:
-      if self.DefineDosDevice(int(self.DDD_REMOVE_DEFINITION),
-                              self.subst_drive,
-                              self.real_path) == 0:
-        raise RuntimeError('Unable to remove subst')
-  def ShortenedPath(self):
-    return self.subst_drive + '\\'
-  def RealPath(self):
-    return self.real_path
-def TempDir():
-  """Generates a temporary directory (for downloading or extracting to) and keep
-  track of the directory that's created for cleaning up later.
-  """
-  temp = tempfile.mkdtemp()
-  g_temp_dirs.append(temp)
-  return temp
-def DeleteAllTempDirs():
-  """Removes all temporary directories created by |TempDir()|."""
-  global g_temp_dirs
-  if g_temp_dirs:
-    sys.stdout.write('Cleaning up temporaries...\n')
-  for temp in g_temp_dirs:
-    # shutil.rmtree errors out on read only attributes.
-    RunOrDie('rmdir /s/q "%s"' % temp)
-  g_temp_dirs = []
-def GetMainIsoUrl(pro):
-  """Gets the main .iso URL.
-  If |pro| is False, downloads the Express edition.
-  """
-  prefix = 'http://download.microsoft.com/download/'
-  if pro:
-    return (prefix +
-        'A/F/1/AF128362-A6A8-4DB3-A39A-C348086472CC/VS2013_RTM_PRO_ENU.iso')
-  else:
-    return (prefix +
-        '7/2/E/72E0F986-D247-4289-B9DC-C4FB07374894/VS2013_RTM_DskExp_ENU.iso')
-def Download(url, local_path):
-  """Downloads a large-ish binary file and print some status information while
-  doing so.
-  """
-  sys.stdout.write('Downloading %s...\n' % url)
-  req = urllib2.urlopen(url)
-  content_length = int(req.headers.get('Content-Length', 0))
-  bytes_read = 0L
-  terminator = '\r' if sys.stdout.isatty() else '\n'
-  with open(local_path, 'wb') as file_handle:
-    while True:
-      chunk = req.read(1024 * 1024)
-      if not chunk:
-        break
-      bytes_read += len(chunk)
-      file_handle.write(chunk)
-      sys.stdout.write('... %d/%d%s' % (bytes_read, content_length, terminator))
-      sys.stdout.flush()
-  sys.stdout.write('\n')
-  if content_length and content_length != bytes_read:
-    sys.exit('Got incorrect number of bytes downloading %s' % url)
-def ExtractIso(iso_path):
-  """Uses 7zip to extract the contents of the given .iso (or self-extracting
-  .exe).
-  """
-  target_path = TempDir()
-  sys.stdout.write('Extracting %s...\n' % iso_path)
-  sys.stdout.flush()
-  # TODO(scottmg): Do this (and exe) manually with python code.
-  # Note that at the beginning of main() we set the working directory to 7z's
-  # location so that 7z can find its codec dll.
-  RunOrDie('7z x "%s" -y "-o%s"' % (iso_path, target_path))
-  return target_path
-def ExtractMsi(msi_path):
-  """Uses msiexec to extract the contents of the given .msi file."""
-  sys.stdout.write('Extracting %s...\n' % msi_path)
-  with ScopedSubstTempDir() as temp_dir:
-    RunOrDie('msiexec /a "%s" /qn TARGETDIR="%s"' % (
-               msi_path, temp_dir.ShortenedPath()))
-    return temp_dir.RealPath()
-def DownloadMainIso(url):
-  temp_dir = TempDir()
-  target_path = os.path.join(temp_dir, os.path.basename(url))
-  Download(url, target_path)
-  return target_path
-def DownloadSDK8():
-  """Downloads the Win8 SDK.
-  This one is slightly different than the simpler direct downloads. There is
-  no .ISO distribution for the Windows 8 SDK. Rather, a tool is provided that
-  is a download manager. This is used to download the various .msi files to a
-  target location. Unfortunately, this tool requires elevation for no obvious
-  reason even when only downloading, so this function will trigger a UAC
-  elevation if the script is not run from an elevated prompt. This is mostly
-  grabbed for windbg and cdb (See http://crbug.com/321187) as most of the SDK
-  is in VS2013, however we need a couple D3D related things from the SDK.
-  """
-  # Use the long path name here because because 8dot3 names don't seem to work.
-  sdk_temp_dir = GetLongPathName(TempDir())
-  target_path = os.path.join(sdk_temp_dir, 'sdksetup.exe')
-  standalone_path = os.path.join(sdk_temp_dir, 'Standalone')
-  Download(
-      ('http://download.microsoft.com/download/'
-       'F/1/3/F1300C9C-A120-4341-90DF-8A52509B23AC/standalonesdk/sdksetup.exe'),
-      target_path)
-  sys.stdout.write(
-      'Running sdksetup.exe to download Win8 SDK (may request elevation)...\n')
-  count = 0
-  while count < 5:
-    rc = subprocess.call([target_path,
-                          '/quiet',
-                          '/features', 'OptionId.WindowsDesktopDebuggers',
-                              'OptionId.WindowsDesktopSoftwareDevelopmentKit',
-                          '/layout', standalone_path])
-    if rc == 0:
-      return standalone_path
-    count += 1
-    sys.stdout.write('Windows 8 SDK failed to download, retrying.\n')
-  sys.exit('After multiple retries, couldn\'t download Win8 SDK')
-def DownloadWDKIso():
-  wdk_temp_dir = TempDir()
-  target_path = os.path.join(wdk_temp_dir, 'GRMWDK_EN_7600_1.ISO')
-  Download(WDK_ISO_URL, target_path)
-  return target_path
-def DownloadUsingGsutil(filename):
-  """Downloads the given file from Google Storage chrome-wintoolchain bucket."""
-  temp_dir = TempDir()
-  assert os.path.basename(filename) == filename
-  target_path = os.path.join(temp_dir, filename)
-  gsutil = download_from_google_storage.Gsutil(
-      download_from_google_storage.GSUTIL_DEFAULT_PATH, boto_path=None)
-  code = gsutil.call('cp', 'gs://chrome-wintoolchain/' + filename, target_path)
-  if code != 0:
-    sys.exit('gsutil failed')
-  return target_path
-def GetVSInternal():
-  """Uses gsutil to pull the toolchain from internal Google Storage bucket."""
-  return DownloadUsingGsutil('VS2013_RTM_PRO_ENU.iso')
-def GetSDKInternal():
-  """Downloads a zipped copy of the SDK from internal Google Storage bucket,
-  and extracts it."""
-  zip_file = DownloadUsingGsutil('Standalone.zip')
-  return ExtractIso(zip_file)
-class SourceImages(object):
-  """Local paths for components. |wdk_path| may be None if it's unnecessary for
-  the given configuration."""
-  def __init__(self, vs_path, sdk8_path, wdk_path):
-    self.vs_path = vs_path
-    self.sdk8_path = sdk8_path
-    self.wdk_path = wdk_path
-def GetSourceImages(local_dir, pro):
-  """Downloads the various sources that we need.
-  Of note: Because Express does not include ATL, there's an additional download
-  of the 7.1 WDK which is the latest publically accessible source for ATL. When
-  |pro| this is not necessary (and CHROME_HEADLESS always implies Pro).
-  """
-  if pro and not local_dir:
-    sys.exit('Non-Express must be used with --local')
-  url = GetMainIsoUrl(pro)
-  if local_dir:
-    wdk_path = (os.path.join(local_dir, os.path.basename(WDK_ISO_URL))
-                if not pro else None)
-    return SourceImages(os.path.join(local_dir, os.path.basename(url)),
-                        os.path.join(local_dir, 'Standalone'),
-                        wdk_path=wdk_path)
-  else:
-    # Note that we do the SDK first, as it might cause an elevation prompt.
-    sdk8_path = DownloadSDK8()
-    vs_path = DownloadMainIso(url)
-    wdk_path = DownloadWDKIso() if not pro else None
-    return SourceImages(vs_path, sdk8_path, wdk_path=wdk_path)
-def ExtractMsiList(root_dir, packages):
-  """Extracts the contents of a list of .msi files from an already extracted
-  .iso file.
-  |packages| is a list of pairs (msi, required). If required is not True, the
-  msi is optional (this is set for packages that are in Pro but not Express).
-  """
-  results = []
-  for (package, required) in packages:
-    path_to_package = os.path.join(root_dir, package)
-    if not os.path.exists(path_to_package) and not required:
-      continue
-    results.append(ExtractMsi(path_to_package))
-  return results
-def ExtractComponents(image):
-  vs_packages = [
-      (r'vcRuntimeAdditional_amd64\vc_runtimeAdditional_x64.msi', True),
-      (r'vcRuntimeAdditional_x86\vc_runtimeAdditional_x86.msi', True),
-      (r'vcRuntimeDebug_amd64\vc_runtimeDebug_x64.msi', True),
-      (r'vcRuntimeDebug_x86\vc_runtimeDebug_x86.msi', True),
-      (r'vcRuntimeMinimum_amd64\vc_runtimeMinimum_x64.msi', True),
-      (r'vcRuntimeMinimum_x86\vc_runtimeMinimum_x86.msi', True),
-      (r'vc_compilerCore86\vc_compilerCore86.msi', True),
-      (r'vc_compilerCore86res\vc_compilerCore86res.msi', True),
-      (r'vc_compilerx64nat\vc_compilerx64nat.msi', False),
-      (r'vc_compilerx64natres\vc_compilerx64natres.msi', False),
-      (r'vc_compilerx64x86\vc_compilerx64x86.msi', False),
-      (r'vc_compilerx64x86res\vc_compilerx64x86res.msi', False),
-      (r'vc_librarycore86\vc_librarycore86.msi', True),
-      (r'vc_libraryDesktop\x64\vc_LibraryDesktopX64.msi', True),
-      (r'vc_libraryDesktop\x86\vc_LibraryDesktopX86.msi', True),
-      (r'vc_libraryextended\vc_libraryextended.msi', False),
-      (r'professionalcore\Setup\vs_professionalcore.msi', False),
-      (r'vc_libraryselectablemfc\vc_libraryselectablemfc.msi', False),
-    ]
-  extracted_iso = ExtractIso(image.vs_path)
-  result = ExtractMsiList(os.path.join(extracted_iso, 'packages'), vs_packages)
-  sdk_packages = [
-      (r'X86 Debuggers And Tools-x86_en-us.msi', True),
-      (r'X64 Debuggers And Tools-x64_en-us.msi', True),
-      (r'SDK Debuggers-x86_en-us.msi', True),
-      (r'Windows Software Development Kit-x86_en-us.msi', True),
-      (r'Windows Software Development Kit for Metro style Apps-x86_en-us.msi',
-          True),
-    ]
-  result.extend(ExtractMsiList(os.path.join(image.sdk8_path, 'Installers'),
-                               sdk_packages))
-  if image.wdk_path:
-    # This image will only be set when using Express, when we need the WDK
-    # headers and libs to supplement Express with ATL.
-    wdk_packages = [
-      (r'headers.msi', True),
-      (r'libs_x86fre.msi', True),
-      (r'libs_x64fre.msi', True),
-    ]
-    extracted_iso = ExtractIso(image.wdk_path)
-    result.extend(ExtractMsiList(os.path.join(extracted_iso, 'WDK'),
-                                 wdk_packages))
-  return result
-def CopyToFinalLocation(extracted_dirs, target_dir):
-  sys.stdout.write('Copying to final location...\n')
-  mappings = {
-      'Program Files\\Microsoft Visual Studio 12.0\\VC\\': 'VC\\',
-      'Program Files\\Microsoft Visual Studio 12.0\\DIA SDK\\': 'DIA SDK\\',
-      'System64\\': 'sys64\\',
-      'System\\': 'sys32\\',
-      'Windows Kits\\8.1\\': 'win8sdk\\',
-      'WinDDK\\7600.16385.win7_wdk.100208-1538\\': 'wdk\\',
-  }
-  matches = []
-  for extracted_dir in extracted_dirs:
-    for root, _, filenames in os.walk(extracted_dir):
-      for filename in filenames:
-        matches.append((extracted_dir, os.path.join(root, filename)))
-  copies = []
-  for prefix, full_path in matches:
-    # +1 for trailing \.
-    partial_path = full_path[len(prefix) + 1:]
-    for map_from, map_to in mappings.iteritems():
-      if partial_path.startswith(map_from):
-        target_path = os.path.join(map_to, partial_path[len(map_from):])
-        copies.append((full_path, os.path.join(target_dir, target_path)))
-  for full_source, full_target in copies:
-    target_dir = os.path.dirname(full_target)
-    if not os.path.isdir(target_dir):
-      os.makedirs(target_dir)
-    shutil.copy2(full_source, full_target)
-def GenerateSetEnvCmd(target_dir, pro):
-  """Generate a batch file that gyp expects to exist to set up the compiler
-  environment.
-  This is normally generated by a full install of the SDK, but we
-  do it here manually since we do not do a full install."""
-  with open(os.path.join(
-        target_dir, r'win8sdk\bin\SetEnv.cmd'), 'w') as f:
-    f.write('@echo off\n'
-            ':: Generated by win_toolchain\\toolchain2013.py.\n'
-            # Common to x86 and x64
-            'set PATH=%~dp0..\\..\\Common7\\IDE;%PATH%\n'
-            'set INCLUDE=%~dp0..\\..\\win8sdk\\Include\\um;'
-               '%~dp0..\\..\\win8sdk\\Include\\shared;'
-               '%~dp0..\\..\\VC\\include;'
-               '%~dp0..\\..\\VC\\atlmfc\\include\n'
-            'if "%1"=="/x64" goto x64\n')
-    # x86. If we're Pro, then use the amd64_x86 cross (we don't support x86
-    # host at all).
-    if pro:
-      f.write('set PATH=%~dp0..\\..\\win8sdk\\bin\\x86;'
-                '%~dp0..\\..\\VC\\bin\\amd64_x86;'
-                '%~dp0..\\..\\VC\\bin\\amd64;'  # Needed for mspdb120.dll.
-                '%PATH%\n')
-    else:
-      f.write('set PATH=%~dp0..\\..\\win8sdk\\bin\\x86;'
-                '%~dp0..\\..\\VC\\bin;%PATH%\n')
-    f.write('set LIB=%~dp0..\\..\\VC\\lib;'
-               '%~dp0..\\..\\win8sdk\\Lib\\winv6.3\\um\\x86;'
-               '%~dp0..\\..\\VC\\atlmfc\\lib\n'
-            'goto :EOF\n')
-    # Express does not include a native 64 bit compiler, so we have to use
-    # the x86->x64 cross.
-    if not pro:
-      # x86->x64 cross.
-      f.write(':x64\n'
-              'set PATH=%~dp0..\\..\\win8sdk\\bin\\x64;'
-                 '%~dp0..\\..\\VC\\bin\\x86_amd64;'
-                 # Needed for mspdb120.dll. Must be after above though, so
-                 # that cl.exe is the x86_amd64 one.
-                 '%~dp0..\\..\\VC\\bin;'
-                 '%PATH%\n')
-    else:
-      # x64 native.
-      f.write(':x64\n'
-              'set PATH=%~dp0..\\..\\win8sdk\\bin\\x64;'
-                 '%~dp0..\\..\\VC\\bin\\amd64;'
-                 '%PATH%\n')
-    f.write('set LIB=%~dp0..\\..\\VC\\lib\\amd64;'
-               '%~dp0..\\..\\win8sdk\\Lib\\winv6.3\\um\\x64;'
-               '%~dp0..\\..\\VC\\atlmfc\\lib\\amd64\n')
-def DoTreeMirror(target_dir, tree_sha1):
-  """In order to save temporary space on bots that do not have enough space to
-  download ISOs, unpack them, and copy to the target location, the whole tree
-  is uploaded as a zip to internal storage, and then mirrored here."""
-  local_zip = DownloadUsingGsutil(tree_sha1 + '.zip')
-  sys.stdout.write('Extracting %s...\n' % local_zip)
-  sys.stdout.flush()
-  RunOrDie('7z x "%s" -y "-o%s"' % (local_zip, target_dir))
-def main():
-  parser = optparse.OptionParser(description=sys.modules[__name__].__doc__)
-  parser.add_option('--targetdir', metavar='DIR',
-                    help='put toolchain into DIR',
-                    default=os.path.join(BASEDIR, 'win_toolchain_2013'))
-  parser.add_option('--noclean', action='store_false', dest='clean',
-                    help='do not remove temp files',
-                    default=True)
-  parser.add_option('--local', metavar='DIR',
-                    help='use downloaded files from DIR')
-  parser.add_option('--express',
-                    help='use VS Express instead of Pro', action='store_true')
-  parser.add_option('--sha1',
-                    help='tree sha1 that can be used to mirror an internal '
-                         'copy (used if --use-gs)')
-  parser.add_option('--use-gs',
-                    help='Use internal servers to pull isos',
-                    default=bool(int(os.environ.get('CHROME_HEADLESS', 0))),
-                    action='store_true')
-  options, _ = parser.parse_args()
-  try:
-    target_dir = os.path.abspath(options.targetdir)
-    if os.path.exists(target_dir):
-      parser.error('%s already exists. Please [re]move it or use '
-                  '--targetdir to select a different target.\n' %
-                  target_dir)
-    # Set the working directory to 7z subdirectory. 7-zip doesn't find its
-    # codec dll very well, so this is the simplest way to make sure it runs
-    # correctly, as we don't otherwise care about working directory.
-    os.chdir(os.path.join(BASEDIR, '7z'))
-    if options.use_gs and options.sha1:
-      options.express = False
-      DoTreeMirror(target_dir, options.sha1)
-    else:
-      images = GetSourceImages(options.local, not options.express)
-      extracted = ExtractComponents(images)
-      CopyToFinalLocation(extracted, target_dir)
-      GenerateSetEnvCmd(target_dir, not options.express)
-    data = {
-        'path': target_dir,
-        'version': '2013e' if options.express else '2013',
-        'win8sdk': os.path.join(target_dir, 'win8sdk'),
-        'wdk': os.path.join(target_dir, 'wdk'),
-        'runtime_dirs': [
-          os.path.join(target_dir, 'sys64'),
-          os.path.join(target_dir, 'sys32'),
-        ],
-    }
-    with open(os.path.join(target_dir, '..', 'data.json'), 'w') as f:
-      json.dump(data, f)
-  finally:
-    if options.clean:
-      DeleteAllTempDirs()
-if __name__ == '__main__':
-  sys.exit(main())