libv8 8.4.255.0

data/vendor/depot_tools/autoninja.bat

@@ -0,0 +1,33 @@
+@echo off
+:: Copyright 2017 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.
+
+setlocal
+
+REM Set unique build ID.
+FOR /f "usebackq tokens=*" %%a in (`python -c "from __future__ import print_function; import uuid; print(uuid.uuid4())"`) do set AUTONINJA_BUILD_ID=%%a
+
+REM If a build performance summary has been requested then also set NINJA_STATUS
+REM to trigger more verbose status updates. In particular this makes it possible
+REM to see how quickly process creation is happening - often a critical clue on
+REM Windows. The trailing space is intentional.
+if "%NINJA_SUMMARIZE_BUILD%" == "1" set NINJA_STATUS=[%%r processes, %%f/%%t @ %%o/s : %%es ] 
+
+REM Execute whatever is printed by autoninja.py.
+REM Also print it to reassure that the right settings are being used.
+FOR /f "usebackq tokens=*" %%a in (`vpython %~dp0autoninja.py "%*"`) do echo %%a & %%a
+@if errorlevel 1 goto buildfailure
+
+REM Use call to invoke vpython script here, because we use vpython via vpython.bat.
+@if "%NINJA_SUMMARIZE_BUILD%" == "1" call vpython.bat %~dp0post_build_ninja_summary.py %*
+@call vpython.bat %~dp0ninjalog_uploader_wrapper.py --cmdline %*
+
+exit /b
+:buildfailure
+
+@call vpython.bat %~dp0ninjalog_uploader_wrapper.py --cmdline %*
+
+REM Return an error code of 1 so that if a developer types:
+REM "autoninja chrome && chrome" then chrome won't run if the build fails.
+cmd /c exit 1

data/vendor/depot_tools/autoninja.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env vpython
+# Copyright (c) 2017 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 (intended to be invoked by autoninja or autoninja.bat) detects
+whether a build is using goma. If so it runs with a large -j value, and
+otherwise it chooses a small one. This auto-adjustment makes using goma simpler
+and safer, and avoids errors that can cause slow goma builds or swap-storms
+on non-goma builds.
+"""
+
+# [VPYTHON:BEGIN]
+# wheel: <
+#   name: "infra/python/wheels/psutil/${vpython_platform}"
+#   version: "version:5.6.2"
+# >
+# [VPYTHON:END]
+
+from __future__ import print_function
+
+import os
+import psutil
+import re
+import sys
+
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+
+# The -t tools are incompatible with -j
+t_specified = False
+j_specified = False
+output_dir = '.'
+input_args = sys.argv
+# On Windows the autoninja.bat script passes along the arguments enclosed in
+# double quotes. This prevents multiple levels of parsing of the special '^'
+# characters needed when compiling a single file but means that this script gets
+# called with a single argument containing all of the actual arguments,
+# separated by spaces. When this case is detected we need to do argument
+# splitting ourselves. This means that arguments containing actual spaces are
+# not supported by autoninja, but that is not a real limitation.
+if (sys.platform.startswith('win') and len(sys.argv) == 2 and
+    input_args[1].count(' ') > 0):
+  input_args = sys.argv[:1] + sys.argv[1].split()
+
+# Ninja uses getopt_long, which allow to intermix non-option arguments.
+# To leave non supported parameters untouched, we do not use getopt.
+for index, arg in enumerate(input_args[1:]):
+  if arg.startswith('-j'):
+    j_specified = True
+  if arg.startswith('-t'):
+    t_specified = True
+  if arg == '-C':
+    # + 1 to get the next argument and +1 because we trimmed off input_args[0]
+    output_dir = input_args[index + 2]
+  elif arg.startswith('-C'):
+    # Support -Cout/Default
+    output_dir = arg[2:]
+
+use_goma = False
+use_jumbo_build = False
+
+# Attempt to auto-detect goma usage.  We support gn-based builds, where we
+# look for args.gn in the build tree, and cmake-based builds where we look for
+# rules.ninja.
+if os.path.exists(os.path.join(output_dir, 'args.gn')):
+  with open(os.path.join(output_dir, 'args.gn')) as file_handle:
+    for line in file_handle:
+      # This regex pattern copied from create_installer_archive.py
+      if re.match(r'^\s*use_goma\s*=\s*true(\s*$|\s*#.*$)', line):
+        use_goma = True
+        continue
+      match_use_jumbo_build = re.match(
+          r'^\s*use_jumbo_build\s*=\s*true(\s*$|\s*#.*$)', line)
+      if match_use_jumbo_build:
+        use_jumbo_build = True
+        continue
+elif os.path.exists(os.path.join(output_dir, 'rules.ninja')):
+  with open(os.path.join(output_dir, 'rules.ninja')) as file_handle:
+    for line in file_handle:
+      if re.match(r'^\s*command\s*=\s*\S+gomacc', line):
+        use_goma = True
+        break
+
+# If GOMA_DISABLED is set to "true", "t", "yes", "y", or "1" (case-insensitive)
+# then gomacc will use the local compiler instead of doing a goma compile. This
+# is convenient if you want to briefly disable goma. It avoids having to rebuild
+# the world when transitioning between goma/non-goma builds. However, it is not
+# as fast as doing a "normal" non-goma build because an extra process is created
+# for each compile step. Checking this environment variable ensures that
+# autoninja uses an appropriate -j value in this situation.
+goma_disabled_env = os.environ.get('GOMA_DISABLED', '0').lower()
+if goma_disabled_env in ['true', 't', 'yes', 'y', '1']:
+  use_goma = False
+
+# Specify ninja.exe on Windows so that ninja.bat can call autoninja and not
+# be called back.
+ninja_exe = 'ninja.exe' if sys.platform.startswith('win') else 'ninja'
+ninja_exe_path = os.path.join(SCRIPT_DIR, ninja_exe)
+
+# Use absolute path for ninja path,
+# or fail to execute ninja if depot_tools is not in PATH.
+args = [ninja_exe_path] + input_args[1:]
+
+num_cores = psutil.cpu_count()
+if not j_specified and not t_specified:
+  if use_goma:
+    args.append('-j')
+    core_multiplier = int(os.environ.get('NINJA_CORE_MULTIPLIER', '40'))
+    j_value = num_cores * core_multiplier
+
+    if sys.platform.startswith('win'):
+      # On windows, j value higher than 1000 does not improve build performance.
+      j_value = min(j_value, 1000)
+    elif sys.platform == 'darwin':
+      # On Mac, j value higher than 500 causes 'Too many open files' error
+      # (crbug.com/936864).
+      j_value = min(j_value, 500)
+
+    args.append('%d' % j_value)
+  else:
+    j_value = num_cores
+    # Ninja defaults to |num_cores + 2|
+    j_value += int(os.environ.get('NINJA_CORE_ADDITION', '2'))
+    if use_jumbo_build:
+      # Compiling a jumbo .o can easily use 1-2GB of memory. Leaving 2GB per
+      # process avoids memory swap/compression storms when also considering
+      # already in-use memory.
+      physical_ram = psutil.virtual_memory().total
+      GB = 1024 * 1024 * 1024
+      j_value = min(j_value, physical_ram / (2 * GB))
+    args.append('-j')
+    args.append('%d' % j_value)
+
+# On Windows, fully quote the path so that the command processor doesn't think
+# the whole output is the command.
+# On Linux and Mac, if people put depot_tools in directories with ' ',
+# shell would misunderstand ' ' as a path separation.
+# TODO(yyanagisawa): provide proper quoting for Windows.
+# see https://cs.chromium.org/chromium/src/tools/mb/mb.py
+for i in range(len(args)):
+  if (i == 0 and sys.platform.startswith('win')) or ' ' in args[i]:
+    args[i] = '"%s"' % args[i].replace('"', '\\"')
+
+if os.environ.get('NINJA_SUMMARIZE_BUILD', '0') == '1':
+  args += ['-d', 'stats']
+
+print(' '.join(args))

data/vendor/depot_tools/bb

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# Copyright 2019 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.
+
+MYPATH=$(dirname "${BASH_SOURCE[0]}")
+
+source "$MYPATH/cipd_bin_setup.sh"
+cipd_bin_setup &> /dev/null
+
+exec "$MYPATH/.cipd_bin/bb" "$@"

data/vendor/depot_tools/bb.bat

@@ -0,0 +1,7 @@
+@echo off
+:: Copyright 2019 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.
+
+call "%~dp0\cipd_bin_setup.bat" > nul 2>&1
+"%~dp0\.cipd_bin\bb.exe" %*

data/vendor/depot_tools/bootstrap/README.md

@@ -0,0 +1,155 @@
+# Windows binary tool bootstrap
+
+This directory has the 'magic' for the `depot_tools` windows binary update
+mechanisms.
+
+A previous Python may actually be in use when it is run, preventing us
+from replacing it outright without breaking running code. To
+ommodate this, and Python cleanup, we handle Python in two stages:
+
+1. Use CIPD to install both Git and Python at once.
+2. Use "win_tools.py" as a post-processor to install generated files and
+   fix-ups.
+
+## Software bootstrapped
+  * Python 2 and 3 (https://www.python.org/)
+  * Git for Windows (https://git-for-windows.github.io/)
+
+## Mechanism
+
+Any time a user runs `gclient` on windows, it will invoke the `depot_tools`
+autoupdate script [depot_tools.bat](../../update_depot_tools.bat). This, in
+turn, will run [win_tools.bat](./win_tools.bat), which does the bulk of the
+work.
+
+`win_tools.bat` will successively look to see if the local version of the binary
+package is present, and if so, if it's the expected version. If either of those
+cases is not true, it will download and unpack the respective binary.
+
+Installation of Git and Python is done by the [win_tools.bat](./win_tools.bat)
+script, which uses CIPD (via the [cipd](/cipd.bat) bootstrap) to acquire and
+install each package into the root of the `depot_tools` repository. Afterwards,
+the [win_tools.py](./win_tools.py) Python script is invoked to install stubs,
+wrappers, and support scripts into `depot_tools` for end-users.
+
+### Manifest
+
+The Git and Python versions are specified in [manifest.txt](./manifest.txt).
+
+There is an associated file,
+[manifest_bleeding_edge.txt](./manifest_bleeding_edge.txt), that can be used
+to canary new versions on select bots. Any bots with a `.bleeding_edge` file
+in their `depot_tools` root will automatically use the bleeding edge manifest.
+This allows opt-in systems to test against new versions of Python or Git. Once
+those versions have been verified correct, `manifest.txt` can be updated to the
+same specification, which will cause the remainder of systems to update.
+
+### Bundles
+
+Git and Python bundle construction is documented in
+[infra packaging](https://chromium.googlesource.com/infra/infra/+/master/doc/packaging/).
+
+Note that in order for the update to take effect, `gclient` currently needs to
+run twice. The first time it will update the `depot_tools` repo, and the second
+time it will see the new git version and update to it. This is a bug that should
+be fixed, in case you're reading this and this paragraph infuriates you more
+than the rest of this README.
+
+## Testing
+
+After any modification to this script set, a test sequence should be run on a
+Windows bot.
+
+The post-processing will regenerate "python.bat" and "python3.bat" to point to
+the current Python instance. Any previous Python installations will stick
+around, but new invocations will use the new instance. Old installations will
+die off either due to processes terminating or systems restarting. When this
+happens, they will be cleaned up by the post-processing script.
+
+Testing
+=======
+
+For each of the following test scenarios, run these commands and verify that
+they are working:
+
+```bash
+:: Assert that `gclient` invocation will update (and do the update).
+gclient version
+
+:: Assert that Python fundamentally works.
+python -c "import Queue; print dir(Queue)"
+
+:: Assert that Python 3 fundamentally works.
+python3 -c "import queue; print(dir(queue))"
+
+:: Assert that Python scripts work from `cmd.exe`.
+git map-branches
+
+:: Assert that `git bash` works.
+git bash
+
+## (Within `git bash`) assert that Python fundamentally works.
+python -c "import Queue; print dir(Queue)"
+## (Within `git bash`) assert that Python 3 fundamentally works.
+python3 -c "import queue; print(dir(queue))"
+## (Within `git bash`) assert that Python scripts work.
+git map-branches
+```
+
+Run this sequence through the following upgrade/downgrade procedures:
+
+* Cold default installation.
+  - Clean `depot_tools` via: `git clean -x -f -d .`
+  - Run through test steps.
+  - Test upgrade to bleeding edge (if it differs).
+    - Run `python.bat` in another shell, keep it open
+    - Run `python3.bat` in another shell, keep it open
+    - Add `.bleeding_edge` to `depot_tools` root.
+    - Run through test steps.
+    - In the old `python.bat` shell, run `import Queue`, confirm that it
+      works.
+    - In the old `python3.bat` shell, run `import queue`, confirm that it
+      works.
+    - Close the Python shell, run `gclient version`, ensure that old directory
+      is cleaned.
+* Cold bleeding edge installation.
+  - Clean `depot_tools` via: `git clean -x -f -d .`
+  - Add `.bleeding_edge` to `depot_tools` root.
+  - Run through test steps.
+  - Test downgrade to default (if it differs).
+    - Run `python.bat` in another shell, keep it open
+    - Run `python3.bat` in another shell, keep it open
+    - Delete `.bleeding_edge` from `depot_tools` root.
+    - Run through test steps.
+    - In the old `python.bat` shell, run `import Queue`, confirm that it
+      works.
+    - In the old `python3.bat` shell, run `import queue`, confirm that it
+      works.
+    - Close the Python shell, run `gclient version`, ensure that old directory
+      is cleaned.
+* Warm bleeding edge upgrade.
+  - Clean `depot_tools` via: `git clean -x -f -d .`
+  - Run `gclient version` to load defaults.
+  - Run `python.bat` in another shell, keep it open
+  - Run `python3.bat` in another shell, keep it open
+  - Add `.bleeding_edge` to `depot_tools` root.
+  - Run through test steps.
+  - In the old `python.bat` shell, run `import Queue`, confirm that it
+    works.
+  - In the old `python3.bat` shell, run `import queue`, confirm that it
+    works.
+  - Close the Python shell, run `gclient version`, ensure that old directory is
+    cleaned.
+* Upgradable and Revertible.
+  - Checkout current `HEAD`.
+  - Run `gclient version` to load HEAD toolchain (initial).
+  - Apply the candidate patch.
+  - Run through test steps (upgrade).
+  - Checkout current `HEAD` again.
+  - Run `gclient version` to load HEAD toolchain (revert).
+  - Run through test steps.
+
+This will take some time, but will ensure that all affected bots and users
+should not encounter any problems due to the change. As systems and users are
+migrated off of this implicit bootstrap, the testing procedure will become less
+critical.

data/vendor/depot_tools/bootstrap/bootstrap.py

@@ -0,0 +1,356 @@
+# Copyright 2016 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 argparse
+import collections
+import contextlib
+import fnmatch
+import hashlib
+import logging
+import os
+import platform
+import posixpath
+import shutil
+import string
+import subprocess
+import sys
+import tempfile
+
+
+THIS_DIR = os.path.abspath(os.path.dirname(__file__))
+ROOT_DIR = os.path.abspath(os.path.join(THIS_DIR, '..'))
+
+DEVNULL = open(os.devnull, 'w')
+
+IS_WIN = sys.platform.startswith('win')
+BAT_EXT = '.bat' if IS_WIN else ''
+
+# Top-level stubs to generate that fall through to executables within the Git
+# directory.
+WIN_GIT_STUBS = {
+  'git.bat': 'cmd\\git.exe',
+  'gitk.bat': 'cmd\\gitk.exe',
+  'ssh.bat': 'usr\\bin\\ssh.exe',
+  'ssh-keygen.bat': 'usr\\bin\\ssh-keygen.exe',
+}
+
+
+# Accumulated template parameters for generated stubs.
+class Template(collections.namedtuple('Template', (
+    'PYTHON_RELDIR', 'PYTHON_BIN_RELDIR', 'PYTHON_BIN_RELDIR_UNIX',
+    'PYTHON3_BIN_RELDIR', 'PYTHON3_BIN_RELDIR_UNIX', 'GIT_BIN_RELDIR',
+    'GIT_BIN_RELDIR_UNIX', 'GIT_PROGRAM',
+    ))):
+
+  @classmethod
+  def empty(cls):
+    return cls(**{k: None for k in cls._fields})
+
+  def maybe_install(self, name, dst_path):
+    """Installs template |name| to |dst_path| if it has changed.
+
+    This loads the template |name| from THIS_DIR, resolves template parameters,
+    and installs it to |dst_path|. See `maybe_update` for more information.
+
+    Args:
+      name (str): The name of the template to install.
+      dst_path (str): The destination filesystem path.
+
+    Returns (bool): True if |dst_path| was updated, False otherwise.
+    """
+    template_path = os.path.join(THIS_DIR, name)
+    with open(template_path, 'r', encoding='utf8') as fd:
+      t = string.Template(fd.read())
+    return maybe_update(t.safe_substitute(self._asdict()), dst_path)
+
+
+def maybe_update(content, dst_path):
+  """Writes |content| to |dst_path| if |dst_path| does not already match.
+
+  This function will ensure that there is a file at |dst_path| containing
+  |content|. If |dst_path| already exists and contains |content|, no operation
+  will be performed, preserving filesystem modification times and avoiding
+  potential write contention.
+
+  Args:
+    content (str): The file content.
+    dst_path (str): The destination filesystem path.
+
+  Returns (bool): True if |dst_path| was updated, False otherwise.
+  """
+  # If the path already exists and matches the new content, refrain from writing
+  # a new one.
+  if os.path.exists(dst_path):
+    with open(dst_path, 'r', encoding='utf-8') as fd:
+      if fd.read() == content:
+        return False
+
+  logging.debug('Updating %r', dst_path)
+  with open(dst_path, 'w', encoding='utf-8') as fd:
+    fd.write(content)
+  os.chmod(dst_path, 0o755)
+  return True
+
+
+def maybe_copy(src_path, dst_path):
+  """Writes the content of |src_path| to |dst_path| if needed.
+
+  See `maybe_update` for more information.
+
+  Args:
+    src_path (str): The content source filesystem path.
+    dst_path (str): The destination filesystem path.
+
+  Returns (bool): True if |dst_path| was updated, False otherwise.
+  """
+  with open(src_path, 'r', encoding='utf-8') as fd:
+    content = fd.read()
+  return maybe_update(content, dst_path)
+
+
+def call_if_outdated(stamp_path, stamp_version, fn):
+  """Invokes |fn| if the stamp at |stamp_path| doesn't match |stamp_version|.
+
+  This can be used to keep a filesystem record of whether an operation has been
+  performed. The record is stored at |stamp_path|. To invalidate a record,
+  change the value of |stamp_version|.
+
+  After |fn| completes successfully, |stamp_path| will be updated to match
+  |stamp_version|, preventing the same update from happening in the future.
+
+  Args:
+    stamp_path (str): The filesystem path of the stamp file.
+    stamp_version (str): The desired stamp version.
+    fn (callable): A callable to invoke if the current stamp version doesn't
+        match |stamp_version|.
+
+  Returns (bool): True if an update occurred.
+  """
+
+  stamp_version = stamp_version.strip()
+  if os.path.isfile(stamp_path):
+    with open(stamp_path, 'r', encoding='utf-8') as fd:
+      current_version = fd.read().strip()
+    if current_version == stamp_version:
+      return False
+
+  fn()
+
+  with open(stamp_path, 'w', encoding='utf-8') as fd:
+    fd.write(stamp_version)
+  return True
+
+
+def _in_use(path):
+  """Checks if a Windows file is in use.
+
+  When Windows is using an executable, it prevents other writers from
+  modifying or deleting that executable. We can safely test for an in-use
+  file by opening it in write mode and checking whether or not there was
+  an error.
+
+  Returns (bool): True if the file was in use, False if not.
+  """
+  try:
+    with open(path, 'r+'):
+      return False
+  except IOError:
+    return True
+
+
+def _toolchain_in_use(toolchain_path):
+  """Returns (bool): True if a toolchain rooted at |path| is in use.
+  """
+  # Look for Python files that may be in use.
+  for python_dir in (
+      os.path.join(toolchain_path, 'python', 'bin'), # CIPD
+      toolchain_path, # Legacy ZIP distributions.
+      ):
+    for component in (
+        os.path.join(python_dir, 'python.exe'),
+        os.path.join(python_dir, 'DLLs', 'unicodedata.pyd'),
+        ):
+      if os.path.isfile(component) and _in_use(component):
+        return True
+  # Look for Pytho:n 3 files that may be in use.
+  python_dir = os.path.join(toolchain_path, 'python3', 'bin')
+  for component in (
+      os.path.join(python_dir, 'python3.exe'),
+      os.path.join(python_dir, 'DLLs', 'unicodedata.pyd'),
+      ):
+    if os.path.isfile(component) and _in_use(component):
+      return True
+  return False
+
+
+
+def _check_call(argv, stdin_input=None, **kwargs):
+  """Wrapper for subprocess.check_call that adds logging."""
+  logging.info('running %r', argv)
+  if stdin_input is not None:
+    kwargs['stdin'] = subprocess.PIPE
+  proc = subprocess.Popen(argv, **kwargs)
+  proc.communicate(input=stdin_input)
+  if proc.returncode:
+    raise subprocess.CalledProcessError(proc.returncode, argv, None)
+
+
+def _safe_rmtree(path):
+  if not os.path.exists(path):
+    return
+
+  def _make_writable_and_remove(path):
+    st = os.stat(path)
+    new_mode = st.st_mode | 0o200
+    if st.st_mode == new_mode:
+      return False
+    try:
+      os.chmod(path, new_mode)
+      os.remove(path)
+      return True
+    except Exception:
+      return False
+
+  def _on_error(function, path, excinfo):
+    if not _make_writable_and_remove(path):
+      logging.warning('Failed to %s: %s (%s)', function, path, excinfo)
+
+  shutil.rmtree(path, onerror=_on_error)
+
+
+def clean_up_old_installations(skip_dir):
+  """Removes Python installations other than |skip_dir|.
+
+  This includes an "in-use" check against the "python.exe" in a given directory
+  to avoid removing Python executables that are currently ruinning. We need
+  this because our Python bootstrap may be run after (and by) other software
+  that is using the bootstrapped Python!
+  """
+  root_contents = os.listdir(ROOT_DIR)
+  for f in ('win_tools-*_bin', 'python27*_bin', 'git-*_bin', 'bootstrap-*_bin'):
+    for entry in fnmatch.filter(root_contents, f):
+      full_entry = os.path.join(ROOT_DIR, entry)
+      if full_entry == skip_dir or not os.path.isdir(full_entry):
+        continue
+
+      logging.info('Cleaning up old installation %r', entry)
+      if not _toolchain_in_use(full_entry):
+        _safe_rmtree(full_entry)
+      else:
+        logging.info('Toolchain at %r is in-use; skipping', full_entry)
+
+
+# Version of "git_postprocess" system configuration (see |git_postprocess|).
+GIT_POSTPROCESS_VERSION = '2'
+
+
+def git_get_mingw_dir(git_directory):
+  """Returns (str) The "mingw" directory in a Git installation, or None."""
+  for candidate in ('mingw64', 'mingw32'):
+    mingw_dir = os.path.join(git_directory, candidate)
+    if os.path.isdir(mingw_dir):
+      return mingw_dir
+  return None
+
+
+def git_postprocess(template, git_directory):
+  # Update depot_tools files for "git help <command>"
+  mingw_dir = git_get_mingw_dir(git_directory)
+  if mingw_dir:
+    docsrc = os.path.join(ROOT_DIR, 'man', 'html')
+    git_docs_dir = os.path.join(mingw_dir, 'share', 'doc', 'git-doc')
+    for name in os.listdir(docsrc):
+      maybe_copy(
+          os.path.join(docsrc, name),
+          os.path.join(git_docs_dir, name))
+  else:
+    logging.info('Could not find mingw directory for %r.', git_directory)
+
+  # Create Git templates and configure its base layout.
+  for stub_name, relpath in WIN_GIT_STUBS.items():
+    stub_template = template._replace(GIT_PROGRAM=relpath)
+    stub_template.maybe_install(
+        'git.template.bat',
+        os.path.join(ROOT_DIR, stub_name))
+
+  # Set-up our system configuration environment. The following set of
+  # parameters is versioned by "GIT_POSTPROCESS_VERSION". If they change,
+  # update "GIT_POSTPROCESS_VERSION" accordingly.
+  def configure_git_system():
+    git_bat_path = os.path.join(ROOT_DIR, 'git.bat')
+    _check_call([git_bat_path, 'config', '--system', 'core.autocrlf', 'false'])
+    _check_call([git_bat_path, 'config', '--system', 'core.filemode', 'false'])
+    _check_call([git_bat_path, 'config', '--system', 'core.preloadindex',
+                 'true'])
+    _check_call([git_bat_path, 'config', '--system', 'core.fscache', 'true'])
+    _check_call([git_bat_path, 'config', '--system', 'protocol.version', '2'])
+
+  call_if_outdated(
+      os.path.join(git_directory, '.git_postprocess'),
+      GIT_POSTPROCESS_VERSION,
+      configure_git_system)
+
+
+def main(argv):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--verbose', action='store_true')
+  parser.add_argument('--bootstrap-name', required=True,
+                      help='The directory of the Python installation.')
+  args = parser.parse_args(argv)
+
+  logging.basicConfig(level=logging.DEBUG if args.verbose else logging.WARN)
+
+  template = Template.empty()._replace(
+      PYTHON_RELDIR=os.path.join(args.bootstrap_name, 'python'),
+      PYTHON_BIN_RELDIR=os.path.join(args.bootstrap_name, 'python', 'bin'),
+      PYTHON_BIN_RELDIR_UNIX=posixpath.join(
+          args.bootstrap_name, 'python', 'bin'),
+      PYTHON3_BIN_RELDIR=os.path.join(args.bootstrap_name, 'python3', 'bin'),
+      PYTHON3_BIN_RELDIR_UNIX=posixpath.join(
+          args.bootstrap_name, 'python3', 'bin'),
+      GIT_BIN_RELDIR=os.path.join(args.bootstrap_name, 'git'),
+      GIT_BIN_RELDIR_UNIX=posixpath.join(args.bootstrap_name, 'git'))
+
+  bootstrap_dir = os.path.join(ROOT_DIR, args.bootstrap_name)
+
+  # Clean up any old Python and Git installations.
+  clean_up_old_installations(bootstrap_dir)
+
+  if IS_WIN:
+    git_postprocess(template, os.path.join(bootstrap_dir, 'git'))
+    templates = [
+        ('git-bash.template.sh', 'git-bash', ROOT_DIR),
+        ('python27.bat', 'python.bat', ROOT_DIR),
+        ('python3.bat', 'python3.bat', ROOT_DIR),
+    ]
+    for src_name, dst_name, dst_dir in templates:
+      # Re-evaluate and regenerate our root templated files.
+      template.maybe_install(src_name, os.path.join(dst_dir, dst_name))
+
+  # Emit our Python bin depot-tools-relative directory. This is read by
+  # python.bat, python3.bat, vpython[.bat] and vpython3[.bat] to identify the
+  # path of the current Python installation.
+  #
+  # We use this indirection so that upgrades can change this pointer to
+  # redirect "python.bat" to a new Python installation. We can't just update
+  # "python.bat" because batch file executions reload the batch file and seek
+  # to the previous cursor in between every command, so changing the batch
+  # file contents could invalidate any existing executions.
+  #
+  # The intention is that the batch file itself never needs to change when
+  # switching Python versions.
+
+  maybe_update(
+      template.PYTHON_BIN_RELDIR,
+      os.path.join(ROOT_DIR, 'python_bin_reldir.txt'))
+
+  maybe_update(
+      template.PYTHON3_BIN_RELDIR,
+      os.path.join(ROOT_DIR, 'python3_bin_reldir.txt'))
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))