libv8 7.3.492.27.1 → 8.4.255.0

data/vendor/depot_tools/autoninja

@@ -5,25 +5,31 @@
 # found in the LICENSE file.
 
 # Set unique build ID.
-AUTONINJA_BUILD_ID="$(python -c "import uuid; print uuid.uuid4()")"
+AUTONINJA_BUILD_ID="$(vpython -c "import uuid; print(uuid.uuid4())")"
 export AUTONINJA_BUILD_ID
 
+if [ "$NINJA_SUMMARIZE_BUILD" == "1" ]; then
+    export NINJA_STATUS="[%r processes, %f/%t @ %o/s : %es ] "
+fi
+
 # Execute whatever is printed by autoninja.py.
 # Also print it to reassure that the right settings are being used.
-command=$(python "$(dirname -- "$0")/autoninja.py" "$@")
-echo "$command"
+command=$(vpython "$(dirname -- "$0")/autoninja.py" "$@")
+if [ "$NINJA_SUMMARIZE_BUILD" == "1" ]; then
+  echo "$command"
+fi
 if eval "$command"; then
   if [ "$NINJA_SUMMARIZE_BUILD" == "1" ]; then
-    python "$(dirname -- "$0")/post_build_ninja_summary.py" "$@"
+    vpython "$(dirname -- "$0")/post_build_ninja_summary.py" "$@"
   fi
 
   # Collect ninjalog from googler.
-  "$(dirname -- "$0")/ninjalog_uploader_wrapper.py" --cmd $command
+  vpython "$(dirname -- "$0")/ninjalog_uploader_wrapper.py" --cmd $command
   exit
 fi
 
 # Collect ninjalog from googler.
-"$(dirname -- "$0")/ninjalog_uploader_wrapper.py" --cmd $command
+vpython "$(dirname -- "$0")/ninjalog_uploader_wrapper.py" --cmd $command
 
 # Return an error code of 1 so that if a developer types:
 # "autoninja chrome && chrome" then chrome won't run if the build fails.

data/vendor/depot_tools/autoninja.bat

@@ -3,22 +3,30 @@
 :: 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 "import uuid; print uuid.uuid4()"`) do set AUTONINJA_BUILD_ID=%%a
+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 (`python %~dp0autoninja.py "%*"`) do echo %%a & %%a
+FOR /f "usebackq tokens=*" %%a in (`vpython %~dp0autoninja.py "%*"`) do echo %%a & %%a
 @if errorlevel 1 goto buildfailure
 
-REM Use call to invoke python script here, because we use python via python.bat.
-@if "%NINJA_SUMMARIZE_BUILD%" == "1" call python.bat %~dp0post_build_ninja_summary.py %*
-@call python.bat %~dp0ninjalog_uploader_wrapper.py --cmdline %*
+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 python.bat %~dp0ninjalog_uploader_wrapper.py --cmdline %*
+@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.

data/vendor/depot_tools/autoninja.py

@@ -1,3 +1,4 @@
+#!/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.
@@ -10,8 +11,17 @@ and safer, and avoids errors that can cause slow goma builds or swap-storms
 on non-goma builds.
 """
 
-import multiprocessing
+# [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
 
@@ -48,23 +58,40 @@ for index, arg in enumerate(input_args[1:]):
     output_dir = arg[2:]
 
 use_goma = False
-try:
-  # If GOMA_DISABLED is set (to anything) 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.
-  if 'GOMA_DISABLED' not in os.environ:
-    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
-        m = re.match('^\s*use_goma\s*=\s*true(\s*$|\s*#.*$)', line)
-        if m:
-          use_goma = True
-except IOError:
-  pass
+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.
@@ -75,11 +102,11 @@ ninja_exe_path = os.path.join(SCRIPT_DIR, ninja_exe)
 # or fail to execute ninja if depot_tools is not in PATH.
 args = [ninja_exe_path] + input_args[1:]
 
-num_cores = multiprocessing.cpu_count()
+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"))
+    core_multiplier = int(os.environ.get('NINJA_CORE_MULTIPLIER', '40'))
     j_value = num_cores * core_multiplier
 
     if sys.platform.startswith('win'):
@@ -92,20 +119,30 @@ if not j_specified and not t_specified:
 
     args.append('%d' % j_value)
   else:
-    core_addition = os.environ.get("NINJA_CORE_ADDITION")
-    if core_addition:
-      core_addition = int(core_addition)
-      args.append('-j')
-      args.append('%d' % (num_cores + core_addition))
+    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 quating for Windows.
+# 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('"', '\\"')
 
-print ' '.join(args)
+if os.environ.get('NINJA_SUMMARIZE_BUILD', '0') == '1':
+  args += ['-d', 'stats']
+
+print(' '.join(args))

data/vendor/depot_tools/bb

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/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

data/vendor/depot_tools/bootstrap/{win/README.md → README.md}

@@ -12,7 +12,7 @@ ommodate this, and Python cleanup, we handle Python in two stages:
    fix-ups.
 
 ## Software bootstrapped
-  * Python (https://www.python.org/)
+  * Python 2 and 3 (https://www.python.org/)
   * Git for Windows (https://git-for-windows.github.io/)
 
 ## Mechanism
@@ -60,10 +60,10 @@ than the rest of this README.
 After any modification to this script set, a test sequence should be run on a
 Windows bot.
 
-The post-processing will regenerate "python.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
+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
@@ -73,20 +73,25 @@ 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).
+:: Assert that `gclient` invocation will update (and do the update).
 gclient version
 
-# Assert that Python fundamentally works.
-python -c "import psutil; print dir(psutil)"
+:: Assert that Python fundamentally works.
+python -c "import Queue; print dir(Queue)"
 
-# Assert that Python scripts work from `cmd.exe`.
+:: 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.
+:: Assert that `git bash` works.
 git bash
 
 ## (Within `git bash`) assert that Python fundamentally works.
-python -c "import psutil; print dir(psutil)"
+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
 ```
@@ -98,9 +103,12 @@ Run this sequence through the following upgrade/downgrade procedures:
   - 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 psutil`, confirm that it
+    - 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.
@@ -110,9 +118,12 @@ Run this sequence through the following upgrade/downgrade procedures:
   - 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 psutil`, confirm that it
+    - 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.
@@ -120,9 +131,12 @@ Run this sequence through the following upgrade/downgrade procedures:
   - 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 psutil`, confirm that it
+  - 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.

data/vendor/depot_tools/bootstrap/{win/win_tools.py → bootstrap.py}

@@ -19,15 +19,16 @@ import tempfile
 
 
 THIS_DIR = os.path.abspath(os.path.dirname(__file__))
-ROOT_DIR = os.path.abspath(os.path.join(THIS_DIR, '..', '..'))
+ROOT_DIR = os.path.abspath(os.path.join(THIS_DIR, '..'))
 
 DEVNULL = open(os.devnull, 'w')
 
-BAT_EXT = '.bat' if sys.platform.startswith('win') else ''
+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.
-STUBS = {
+WIN_GIT_STUBS = {
   'git.bat': 'cmd\\git.exe',
   'gitk.bat': 'cmd\\gitk.exe',
   'ssh.bat': 'usr\\bin\\ssh.exe',
@@ -38,7 +39,8 @@ STUBS = {
 # 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',
+    'PYTHON3_BIN_RELDIR', 'PYTHON3_BIN_RELDIR_UNIX', 'GIT_BIN_RELDIR',
+    'GIT_BIN_RELDIR_UNIX', 'GIT_PROGRAM',
     ))):
 
   @classmethod
@@ -58,7 +60,7 @@ class Template(collections.namedtuple('Template', (
     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:
+    with open(template_path, 'r', encoding='utf8') as fd:
       t = string.Template(fd.read())
     return maybe_update(t.safe_substitute(self._asdict()), dst_path)
 
@@ -80,13 +82,14 @@ def maybe_update(content, dst_path):
   # 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:
+    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') as fd:
+  with open(dst_path, 'w', encoding='utf-8') as fd:
     fd.write(content)
+  os.chmod(dst_path, 0o755)
   return True
 
 
@@ -101,7 +104,7 @@ def maybe_copy(src_path, dst_path):
 
   Returns (bool): True if |dst_path| was updated, False otherwise.
   """
-  with open(src_path, 'r') as fd:
+  with open(src_path, 'r', encoding='utf-8') as fd:
     content = fd.read()
   return maybe_update(content, dst_path)
 
@@ -127,14 +130,14 @@ def call_if_outdated(stamp_path, stamp_version, fn):
 
   stamp_version = stamp_version.strip()
   if os.path.isfile(stamp_path):
-    with open(stamp_path, 'r') as fd:
+    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') as fd:
+  with open(stamp_path, 'w', encoding='utf-8') as fd:
     fd.write(stamp_version)
   return True
 
@@ -164,12 +167,20 @@ def _toolchain_in_use(toolchain_path):
       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
+    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
 
 
@@ -191,7 +202,7 @@ def _safe_rmtree(path):
 
   def _make_writable_and_remove(path):
     st = os.stat(path)
-    new_mode = st.st_mode | 0200
+    new_mode = st.st_mode | 0o200
     if st.st_mode == new_mode:
       return False
     try:
@@ -217,7 +228,7 @@ def clean_up_old_installations(skip_dir):
   that is using the bootstrapped Python!
   """
   root_contents = os.listdir(ROOT_DIR)
-  for f in ('win_tools-*_bin', 'python27*_bin', 'git-*_bin'):
+  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):
@@ -257,7 +268,7 @@ def git_postprocess(template, git_directory):
     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():
+  for stub_name, relpath in WIN_GIT_STUBS.items():
     stub_template = template._replace(GIT_PROGRAM=relpath)
     stub_template.maybe_install(
         'git.template.bat',
@@ -284,30 +295,42 @@ def git_postprocess(template, git_directory):
 def main(argv):
   parser = argparse.ArgumentParser()
   parser.add_argument('--verbose', action='store_true')
-  parser.add_argument('--win-tools-name', required=True,
+  parser.add_argument('--bootstrap-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_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.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'))
+          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'))
 
-  win_tools_dir = os.path.join(ROOT_DIR, args.win_tools_name)
-  git_postprocess(template, os.path.join(win_tools_dir, 'git'))
+  bootstrap_dir = os.path.join(ROOT_DIR, args.bootstrap_name)
 
   # 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.
+  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
@@ -317,20 +340,14 @@ def main(argv):
   #
   # 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'))
 
-  python_bat_template = ('python27.new.bat' if not args.bleeding_edge
-                         else 'python27.bleeding_edge.bat')
-
-  # 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'),
-      (python_bat_template, 'python.bat'),
-      ):
-    template.maybe_install(src_name, os.path.join(ROOT_DIR, dst_name))
+  maybe_update(
+      template.PYTHON3_BIN_RELDIR,
+      os.path.join(ROOT_DIR, 'python3_bin_reldir.txt'))
 
   return 0