libv8 5.7.492.65.1 → 5.9.211.38.0beta0

data/vendor/depot_tools/bootstrap/win/manifest_bleeding_edge.txt

@@ -0,0 +1,18 @@
+# CIPD manifest for Windows tools.
+#
+# We must install anything that we want included on PATH to a different
+# subdirectory than Git, as Git's msys bash strips its root directory
+# from PATH, hence the subdirs.
+#
+# If any paths or package layouts change, updates will be required in
+# "win_tools.bat" and "win_tools.py" templates.
+#
+# "win_tools.bat" has a hard requirement that the Python package contains the
+# string "cpython" and ends with the CIPD tag "version:VERSION". It uses this
+# to extract VERSION.
+
+@Subdir python
+infra/python/cpython/${platform} version:2.7.13.chromium7
+
+@Subdir git
+infra/git/${platform} version:2.10.0

data/vendor/depot_tools/bootstrap/win/python27.new.bat

@@ -0,0 +1,49 @@
+@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
+set PYTHON_BAT_RUNNER=1
+
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+:: This file is automatically generated by "bootstrap\win\win_tools.py", and
+:: should not be modified.
+::
+:: The previous "::" block acts as a nop-sled. Each time a batch file executes
+:: a command, it reloads itself and seeks to its previous execution offset to
+:: begin execution. Updating this batch file is, therefore, risky, since any
+:: running Python instance that is using the old batch file will reload the new
+:: batch file once the Python command terminates and resume at some unknown
+:: offset.
+::
+:: With the sled in place, a previous instance will resume mid-label. We are
+:: assuming that the offset of the Python invocation is greater than the
+:: PYTHON_BAT_RUNNER set command, which is the case since the old instance has
+:: a large PATH set block before the Python execution. Old instances will hit
+:: the next block of code without PYTHON_BAT_RUNNER set. New instances will have
+:: it set.
+::
+:: We remedy this in the future by having the batch file load its core paths
+:: from an external file via "set /p", removing the need to modify "python.bat"
+:: during upgrade.
+::
+:: After all of the old batch files are believed to be replaced, we can remove
+:: the PYTHON_BAT_RUNNER block and the sled. For this update, old instances
+:: will resume past the end of the file and terminate.
+
+if not "%PYTHON_BAT_RUNNER%" == "1" goto :END
+
+set /p PYTHON_BIN_RELDIR=<%~dp0python_bin_reldir.txt
+set PATH=%~dp0%PYTHON_BIN_RELDIR%;%~dp0%PYTHON_BIN_RELDIR%\Scripts;%PATH%
+"%~dp0%PYTHON_BIN_RELDIR%\python.exe" %*
+
+:END

data/vendor/depot_tools/bootstrap/win/win_tools.bat

@@ -1,78 +1,74 @@
 @echo off
-:: Copyright (c) 2012 The Chromium Authors. All rights reserved.
+:: 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 will determine if python, git, or svn binaries need updates.  It
-:: returns 123 if the user's shell must restart, otherwise !0 is failure
+:: This script will determine if python or git binaries need updates. It
+:: returns !0 as failure
 
-:: Sadly, we can't use SETLOCAL here otherwise it ERRORLEVEL is not correctly
-:: returned.
-
-set CHROME_INFRA_URL=https://storage.googleapis.com/chrome-infra/
-:: It used to be %~dp0 but ADODB.Stream may fail to write to this directory if
-:: the directory DACL is set to elevated integrity level.
-set ZIP_DIR=%TEMP%
+:: Note: we set EnableDelayedExpansion so we can perform string manipulations
+:: in our manifest parsing loop. This only works on Windows XP+.
+setlocal EnableDelayedExpansion
 
 :: Get absolute root directory (.js scripts don't handle relative paths well).
 pushd %~dp0..\..
 set WIN_TOOLS_ROOT_DIR=%CD%
 popd
 
-if "%1" == "force" (
-  set WIN_TOOLS_FORCE=1
-  shift /1
-)
-
-
-:PYTHON_CHECK
-if not exist "%WIN_TOOLS_ROOT_DIR%\python276_bin" goto :PY27_INSTALL
-if not exist "%WIN_TOOLS_ROOT_DIR%\python.bat" goto :PY27_INSTALL
-set ERRORLEVEL=0
-goto :GIT_CHECK
-
-
-:PY27_INSTALL
-echo Installing python 2.7.6...
-:: Cleanup python directory if it was existing.
-set PYTHON_URL=%CHROME_INFRA_URL%python276_bin.zip
-if exist "%WIN_TOOLS_ROOT_DIR%\python276_bin\." rd /q /s "%WIN_TOOLS_ROOT_DIR%\python276_bin"
-if exist "%ZIP_DIR%\python276.zip" del "%ZIP_DIR%\python276.zip"
-echo Fetching from %PYTHON_URL%
-cscript //nologo //e:jscript "%~dp0get_file.js" %PYTHON_URL% "%ZIP_DIR%\python276_bin.zip"
-if errorlevel 1 goto :PYTHON_FAIL
-:: Will create python276_bin\...
-cscript //nologo //e:jscript "%~dp0unzip.js" "%ZIP_DIR%\python276_bin.zip" "%WIN_TOOLS_ROOT_DIR%"
-:: Create the batch files.
-call copy /y "%~dp0python276.new.bat" "%WIN_TOOLS_ROOT_DIR%\python.bat" 1>nul
-call copy /y "%~dp0pylint.new.bat" "%WIN_TOOLS_ROOT_DIR%\pylint.bat" 1>nul
-del "%ZIP_DIR%\python276_bin.zip"
-set ERRORLEVEL=0
-goto :GIT_CHECK
-
+:: Extra arguments to pass to our "win_tools.py" script.
+set WIN_TOOLS_EXTRA_ARGS=
 
-:PYTHON_FAIL
-echo ... Failed to checkout python automatically.
-echo You should get the "prebaked" version at %PYTHON_URL%
-set ERRORLEVEL=1
-goto :END
+:: Determine if we're running a bleeding-edge installation.
+if not exist "%WIN_TOOLS_ROOT_DIR%\.bleeding_edge" (
+  set CIPD_MANIFEST=manifest.txt
+) else (
+  set CIPD_MANIFEST=manifest_bleeding_edge.txt
+  set WIN_TOOLS_EXTRA_ARGS=%WIN_TOOLS_EXTRA_ARGS% --bleeding-edge
+)
 
-:GIT_CHECK
+:: Parse our CIPD manifest and identify the "cpython" version. We do this by
+:: reading it line-by-line, identifying the line containing "cpython", and
+:: stripping all text preceding "version:". This leaves us with the version
+:: string.
+::
+:: This method requires EnableDelayedExpansion, and extracts the Python version
+:: from our CIPD manifest. Variables referenced using "!" instead of "%" are
+:: delayed expansion variables.
+for /F "tokens=*" %%A in (%~dp0%CIPD_MANIFEST%) do (
+  set LINE=%%A
+  if not "x!LINE:cpython=!" == "x!LINE!" set PYTHON_VERSION=!LINE:*version:=!
+)
+if "%PYTHON_VERSION%" == "" (
+  @echo Could not extract Python version from manifest.
+  set ERRORLEVEL=1
+  goto :END
+)
 
-:: must explicitly use FIND_EXE to prevent this from grabbing e.g. gnuwin32 or
-:: msys versions.
-set FIND_EXE=%SYSTEMROOT%\System32\find.exe
+:: We will take the version string, replace "." with "_", and surround it with
+:: "win-tools-<PYTHON_VERSION>_bin" so that it matches "win_tools.py"'s cleanup
+:: expression and ".gitignore".
+::
+:: We incorporate PYTHON_VERSION into the "win_tools" directory name so that
+:: new installations don't interfere with long-running Python processes if
+:: Python is upgraded.
+set WIN_TOOLS_NAME=win_tools-%PYTHON_VERSION:.=_%_bin
+set WIN_TOOLS_PATH=%WIN_TOOLS_ROOT_DIR%\%WIN_TOOLS_NAME%
+set WIN_TOOLS_EXTRA_ARGS=%WIN_TOOLS_EXTRA_ARGS% --win-tools-name "%WIN_TOOLS_NAME%"
 
-:: Check to see if we're on a 32 or 64 bit system
-:: (parens) are necessary, otherwise batch puts an extra space after 32.
-reg Query "HKLM\Hardware\Description\System\CentralProcessor\0" | %FIND_EXE% /i "x86" > NUL && (set OS_BITS=32) || (set OS_BITS=64)
+:: Install our CIPD packages. The CIPD client self-bootstraps.
+:: See "//cipd.bat" and "//cipd.ps1" for more information.
+set CIPD_EXE=%WIN_TOOLS_ROOT_DIR%\cipd.bat
+call "%CIPD_EXE%" ensure -ensure-file "%~dp0%CIPD_MANIFEST%" -root "%WIN_TOOLS_PATH%"
+if errorlevel 1 goto :END
 
-"%WIN_TOOLS_ROOT_DIR%\python.bat" "%~dp0git_bootstrap.py" --bits "%OS_BITS%"
-goto :END
+:: This executes "win_tools.py" using the bundle's Python interpreter.
+set WIN_TOOLS_PYTHON_BIN=%WIN_TOOLS_PATH%\python\bin\python.exe
+call "%WIN_TOOLS_PYTHON_BIN%" "%~dp0win_tools.py" %WIN_TOOLS_EXTRA_ARGS%
 
-:returncode
-set WIN_TOOLS_ROOT_DIR=
-exit /b %ERRORLEVEL%
 
 :END
-call :returncode %ERRORLEVEL%
+set EXPORT_ERRORLEVEL=%ERRORLEVEL%
+endlocal & (
+  set ERRORLEVEL=%EXPORT_ERRORLEVEL%
+)
+exit /b %ERRORLEVEL%

data/vendor/depot_tools/bootstrap/win/win_tools.py

@@ -0,0 +1,335 @@
+# 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')
+
+BAT_EXT = '.bat' if sys.platform.startswith('win') else ''
+
+# Top-level stubs to generate that fall through to executables within the Git
+# directory.
+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',
+    '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') 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') as fd:
+      if fd.read() == content:
+        return False
+
+  logging.debug('Updating %r', dst_path)
+  with open(dst_path, 'w') as fd:
+    fd.write(content)
+  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') 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') as fd:
+      current_version = fd.read().strip()
+    if current_version == stamp_version:
+      return False
+
+  fn()
+
+  with open(stamp_path, 'w') 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
+  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 | 0200
+    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'):
+    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 = '1'
+
+
+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 STUBS.iteritems():
+    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'])
+
+  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('--win-tools-name', required=True,
+                      help='The directory of the Python installation.')
+  parser.add_argument('--bleeding-edge', action='store_true',
+                      help='Force bleeding edge Git.')
+  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.win_tools_name, 'python'),
+      PYTHON_BIN_RELDIR=os.path.join(args.win_tools_name, 'python', 'bin'),
+      PYTHON_BIN_RELDIR_UNIX=posixpath.join(
+          args.win_tools_name, 'python', 'bin'),
+      GIT_BIN_RELDIR=os.path.join(args.win_tools_name, 'git'),
+      GIT_BIN_RELDIR_UNIX=posixpath.join(args.win_tools_name, 'git'))
+
+  win_tools_dir = os.path.join(ROOT_DIR, args.win_tools_name)
+  git_postprocess(template, os.path.join(win_tools_dir, 'git'))
+
+  # Clean up any old Python and Git installations.
+  clean_up_old_installations(win_tools_dir)
+
+  # Emit our Python bin depot-tools-relative directory. This is ready by
+  # "python.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'))
+
+  # Re-evaluate and regenerate our root templated files.
+  for src_name, dst_name in (
+      ('git-bash.template.sh', 'git-bash'),
+      ('pylint.new.bat', 'pylint.bat'),
+      ('python27.new.bat', 'python.bat'),
+      ):
+    template.maybe_install(src_name, os.path.join(ROOT_DIR, dst_name))
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))