libv8 8.4.255.0

data/vendor/depot_tools/vpython

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+
+# Copyright 2018 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.
+
+if [[ $VPYTHON_BYPASS == "manually managed python not supported by chrome operations" ]]
+then
+  NEWARGS=()
+  while [[ $# -gt 0 ]]
+  do
+    case "$1" in
+      -vpython-tool*) # these tools all do something vpython related and quit
+        exit 0
+        ;;
+      -vpython*=*) # delete any vpython-specific flag (w/ attached argument)
+        shift
+        ;;
+      -vpython*) # delete any vpython-specific flag (w/ separate argument)
+        shift
+        shift
+        ;;
+      --)     # stop parsing
+        NEWARGS+=( "$@" )
+        break
+        ;;
+      *)      # regular arg
+        NEWARGS+=( "$1" )
+        shift
+        ;;
+    esac
+  done
+  exec "python" "${NEWARGS[@]}"
+fi
+
+
+base_dir=$(dirname "$0")
+
+source "$base_dir/cipd_bin_setup.sh"
+cipd_bin_setup &> /dev/null
+
+exec "$base_dir/.cipd_bin/vpython" "$@"

data/vendor/depot_tools/vpython.bat

@@ -0,0 +1,7 @@
+@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.
+
+call "%~dp0\cipd_bin_setup.bat" > nul 2>&1
+"%~dp0\.cipd_bin\vpython.exe" -vpython-interpreter "%~dp0\python.bat" %*

data/vendor/depot_tools/vpython3

@@ -0,0 +1,55 @@
+#!/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.
+
+if [[ $VPYTHON_BYPASS == "manually managed python not supported by chrome operations" ]]
+then
+  NEWARGS=()
+  while [[ $# -gt 0 ]]
+  do
+    case "$1" in
+      -vpython-tool*) # these tools all do something vpython related and quit
+        exit 0
+        ;;
+      -vpython*=*) # delete any vpython-specific flag (w/ attached argument)
+        shift
+        ;;
+      -vpython*) # delete any vpython-specific flag (w/ separate argument)
+        shift
+        shift
+        ;;
+      --)     # stop parsing
+        NEWARGS+=( "$@" )
+        break
+        ;;
+      *)      # regular arg
+        NEWARGS+=( "$1" )
+        shift
+        ;;
+    esac
+  done
+  exec "python3" "${NEWARGS[@]}"
+fi
+
+
+base_dir=$(dirname "$0")
+
+source "$base_dir/cipd_bin_setup.sh"
+cipd_bin_setup &> /dev/null
+
+# If Python bootstrapping is not disabled, make sure Python has been
+# bootstrapped and add it to the front of PATH.
+if [[ $(uname -s) = MINGW* || $(uname -s) = CYGWIN* ]]; then
+  cmd.exe //c $0.bat "$@"
+elif [[ $DEPOT_TOOLS_BOOTSTRAP_PYTHON3 != 0 ]]; then
+  if [[ ! -e "$base_dir/python3_bin_reldir.txt" ]]; then
+    source "$base_dir/bootstrap_python3"
+    bootstrap_python3
+  fi
+  PYTHON3_BIN_RELDIR="$base_dir/$(cat "$base_dir/python3_bin_reldir.txt" | xargs echo)"
+  exec "$base_dir/.cipd_bin/vpython3" -vpython-interpreter  "$PYTHON3_BIN_RELDIR/python3" "$@"
+else
+  exec "$base_dir/.cipd_bin/vpython3" "$@"
+fi

data/vendor/depot_tools/vpython3.bat

@@ -0,0 +1,12 @@
+@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.
+
+:: TODO(crbug.com/1003139): Remove.
+:: Add Python 3 to PATH to work around crbug.com/1003139.
+for /f %%i in (%~dp0python3_bin_reldir.txt) do set PYTHON3_BIN_RELDIR=%%i
+set PATH=%~dp0%PYTHON3_BIN_RELDIR%;%~dp0%PYTHON3_BIN_RELDIR%\Scripts;%~dp0%PYTHON3_BIN_RELDIR%\DLLs;%PATH%
+
+call "%~dp0\cipd_bin_setup.bat" > nul 2>&1
+"%~dp0\.cipd_bin\vpython3.exe" -vpython-interpreter "%~dp0\%PYTHON3_BIN_RELDIR%\python3.exe" %*

data/vendor/depot_tools/watchlists.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+# Copyright (c) 2011 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.
+
+"""Watchlists
+
+Watchlists is a mechanism that allow a developer (a "watcher") to watch over
+portions of code that they are interested in. A "watcher" will be cc-ed to
+changes that modify that portion of code, thereby giving them an opportunity
+to make comments on codereview.chromium.org even before the change is
+committed.
+Refer: http://dev.chromium.org/developers/contributing-code/watchlists
+
+When invoked directly from the base of a repository, this script lists out
+the watchers for files given on the command line. This is useful to verify
+changes to WATCHLISTS files.
+"""
+
+from __future__ import print_function
+
+import logging
+import os
+import re
+import sys
+
+
+class Watchlists(object):
+  """Manage Watchlists.
+
+  This class provides mechanism to load watchlists for a repo and identify
+  watchers.
+  Usage:
+    wl = Watchlists("/path/to/repo/root")
+    watchers = wl.GetWatchersForPaths(["/path/to/file1",
+                                       "/path/to/file2",])
+  """
+
+  _RULES = "WATCHLISTS"
+  _RULES_FILENAME = _RULES
+  _repo_root = None
+  _defns = {}       # Definitions
+  _path_regexps = {}  # Name -> Regular expression mapping
+  _watchlists = {}  # name to email mapping
+
+  def __init__(self, repo_root):
+    self._repo_root = repo_root
+    self._LoadWatchlistRules()
+
+  def _GetRulesFilePath(self):
+    """Returns path to WATCHLISTS file."""
+    return os.path.join(self._repo_root, self._RULES_FILENAME)
+
+  def _HasWatchlistsFile(self):
+    """Determine if watchlists are available for this repo."""
+    return os.path.exists(self._GetRulesFilePath())
+
+  def _ContentsOfWatchlistsFile(self):
+    """Read the WATCHLISTS file and return its contents."""
+    try:
+      watchlists_file = open(self._GetRulesFilePath())
+      contents = watchlists_file.read()
+      watchlists_file.close()
+      return contents
+    except IOError as e:
+      logging.error("Cannot read %s: %s" % (self._GetRulesFilePath(), e))
+      return ''
+
+  def _LoadWatchlistRules(self):
+    """Load watchlists from WATCHLISTS file. Does nothing if not present."""
+    if not self._HasWatchlistsFile():
+      return
+
+    contents = self._ContentsOfWatchlistsFile()
+    watchlists_data = None
+    try:
+      watchlists_data = eval(contents, {'__builtins__': None}, None)
+    except SyntaxError as e:
+      logging.error("Cannot parse %s. %s" % (self._GetRulesFilePath(), e))
+      return
+
+    defns = watchlists_data.get("WATCHLIST_DEFINITIONS")
+    if not defns:
+      logging.error("WATCHLIST_DEFINITIONS not defined in %s" %
+                    self._GetRulesFilePath())
+      return
+    watchlists = watchlists_data.get("WATCHLISTS")
+    if not watchlists:
+      logging.error("WATCHLISTS not defined in %s" % self._GetRulesFilePath())
+      return
+    self._defns = defns
+    self._watchlists = watchlists
+
+    # Compile the regular expressions ahead of time to avoid creating them
+    # on-the-fly multiple times per file.
+    self._path_regexps = {}
+    for name, rule in defns.items():
+      filepath = rule.get('filepath')
+      if not filepath:
+        continue
+      self._path_regexps[name] = re.compile(filepath)
+
+    # Verify that all watchlist names are defined
+    for name in watchlists:
+      if name not in defns:
+        logging.error("%s not defined in %s" % (name, self._GetRulesFilePath()))
+
+  def GetWatchersForPaths(self, paths):
+    """Fetch the list of watchers for |paths|
+
+    Args:
+      paths: [path1, path2, ...]
+
+    Returns:
+      [u1@chromium.org, u2@gmail.com, ...]
+    """
+    watchers = set()  # A set, to avoid duplicates
+    for path in paths:
+      path = path.replace(os.sep, '/')
+      for name, rule in self._path_regexps.items():
+        if name not in self._watchlists:
+          continue
+        if rule.search(path):
+          for watchlist in self._watchlists[name]:
+            watchers.add(watchlist)
+    return sorted(watchers)
+
+
+def main(argv):
+  # Confirm that watchlists can be parsed and spew out the watchers
+  if len(argv) < 2:
+    print("Usage (from the base of repo):")
+    print("  %s [file-1] [file-2] ...." % argv[0])
+    return 1
+  wl = Watchlists(os.getcwd())
+  watchers = wl.GetWatchersForPaths(argv[1:])
+  print(watchers)
+
+
+if __name__ == '__main__':
+  main(sys.argv)

data/vendor/depot_tools/weekly

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# Copyright (c) 2010 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.
+
+"""Display log of checkins of one particular developer since a particular
+date. Only works on git dependencies at the moment."""
+
+from __future__ import print_function
+
+import gclient_utils
+import optparse
+import os
+import re
+import subprocess
+import sys
+
+
+def show_log(path, authors, since='1 week ago'):
+  """Display log in a single git repo."""
+
+  author_option = ' '.join(['--author=' + author for author in authors])
+  command = ' '.join(['git log', author_option, '--since="%s"' % since,
+                      'origin/master', '| git shortlog'])
+  status = subprocess.Popen(['sh', '-c', command],
+                            cwd=path,
+                            stdout=subprocess.PIPE).communicate()[0].rstrip()
+
+  if len(status.splitlines()) > 0:
+    print('---------- %s ----------' % path)
+    print(status)
+
+
+def main():
+  """Take no arguments."""
+
+  option_parser = optparse.OptionParser()
+  option_parser.add_option("-a", "--author", action="append", default=[])
+  option_parser.add_option("-s", "--since", default="1 week ago")
+  options, args = option_parser.parse_args()
+
+  root, entries = gclient_utils.GetGClientRootAndEntries()
+
+  # which entries map to a git repos?
+  paths = [k for k, v in entries.items() if not re.search('svn', v)]
+  paths.sort()
+
+  for path in paths:
+    dir = os.path.normpath(os.path.join(root, path))
+    show_log(dir, options.author, options.since)
+
+
+if __name__ == '__main__':
+  main()

data/vendor/depot_tools/win32imports.py

@@ -0,0 +1,61 @@
+# Copyright 2020 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.
+"""Win32 functions and constants."""
+
+import ctypes
+import ctypes.wintypes
+
+GENERIC_WRITE = 0x40000000
+CREATE_ALWAYS = 0x00000002
+FILE_ATTRIBUTE_NORMAL = 0x00000080
+LOCKFILE_EXCLUSIVE_LOCK = 0x00000002
+LOCKFILE_FAIL_IMMEDIATELY = 0x00000001
+
+
+class Overlapped(ctypes.Structure):
+  """Overlapped is required and used in LockFileEx and UnlockFileEx."""
+  _fields_ = [('Internal', ctypes.wintypes.LPVOID),
+              ('InternalHigh', ctypes.wintypes.LPVOID),
+              ('Offset', ctypes.wintypes.DWORD),
+              ('OffsetHigh', ctypes.wintypes.DWORD),
+              ('Pointer', ctypes.wintypes.LPVOID),
+              ('hEvent', ctypes.wintypes.HANDLE)]
+
+
+# https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+CreateFileW = ctypes.windll.kernel32.CreateFileW
+CreateFileW.argtypes = [
+    ctypes.wintypes.LPCWSTR,  # lpFileName
+    ctypes.wintypes.DWORD,  # dwDesiredAccess
+    ctypes.wintypes.DWORD,  # dwShareMode
+    ctypes.wintypes.LPVOID,  # lpSecurityAttributes
+    ctypes.wintypes.DWORD,  # dwCreationDisposition
+    ctypes.wintypes.DWORD,  # dwFlagsAndAttributes
+    ctypes.wintypes.LPVOID,  # hTemplateFile
+]
+CreateFileW.restype = ctypes.wintypes.HANDLE
+
+# https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-closehandle
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+CloseHandle.argtypes = [
+    ctypes.wintypes.HANDLE,  # hFile
+]
+CloseHandle.restype = ctypes.wintypes.BOOL
+
+# https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-lockfileex
+LockFileEx = ctypes.windll.kernel32.LockFileEx
+LockFileEx.argtypes = [
+    ctypes.wintypes.HANDLE,  # hFile
+    ctypes.wintypes.DWORD,  # dwFlags
+    ctypes.wintypes.DWORD,  # dwReserved
+    ctypes.wintypes.DWORD,  # nNumberOfBytesToLockLow
+    ctypes.wintypes.DWORD,  # nNumberOfBytesToLockHigh
+    ctypes.POINTER(Overlapped),  # lpOverlapped
+]
+LockFileEx.restype = ctypes.wintypes.BOOL
+
+# Commonly used functions are listed here so callers don't need to import
+# ctypes.
+GetLastError = ctypes.GetLastError
+Handle = ctypes.wintypes.HANDLE

data/vendor/depot_tools/win_toolchain/OWNERS

@@ -0,0 +1,2 @@
+brucedawson@chromium.org
+scottmg@chromium.org

data/vendor/depot_tools/win_toolchain/README.md

@@ -0,0 +1,74 @@
+Automatic updates of the Windows toolchain
+==========================================
+
+## On the consumer side, e.g. in Chromium src.git:
+
+- `vs_toolchain.py update` is called early during `DEPS`. `Update()` asks
+  depot\_tools to put in place a particular version of the toolchain (whatever
+  src will currently build with). src provides an output .json file, where
+  `Update()` saves relevant information about the toolchain, the paths, version
+  numbers, etc.
+- Later in `DEPS`, `build/gyp_chromium` uses
+  `vs_toolchain:SetEnvironmentAndGetRuntimeDllDirs()`, which loads the .json
+  file, and uses it to set a few `GYP_` variables and update the `PATH` to
+  include CRT runtime directories (see below).
+- Then, `gyp_chromium` runs gyp generation.
+- Finally, it uses `vs_toolchain` again to copy runtime dlls to the output
+  directories.
+
+The reason the logic was split between `depot_tools` and `src` was because at
+some point, the bots had insufficient hard drive space and if there were > 1
+build directories (say, if a build machine handled the Release and Debug builds
+for a given configuration) then the duplication of the toolchain in both trees
+would cause the bot to run out of disk space.
+
+## On the depot\_tools side:
+
+`get_toolchain_if_necessary.py` takes an output .json file (per above) and an
+input SHA1. It tries to confirm that the user is probably a Google employee (or
+a bot) to encourage them to use the automatic toolchain rather than using a
+system installed one. It then uses gsutil to download the zip corresponding to
+the hash. This requires authentication with @google.com credentials, so it walks
+the user through that process if necessary.
+
+(Previously in the VS2010 and early VS2013 timeframe, we also supported building
+with Express editions of VS. Along with `toolchain2013.py` this script dealt
+with all the complexity of acquiring the Express ISO, SDK bits, patches, etc.
+and applying them all in the correct sequence. However, Express no longer works,
+and Community is not too hard to install properly, so we just let the user do
+that. The primary benefit of having an automatically updated toolchain is that
+it works for bots, allows changes to the toolchain to be tryjob'd, reduces
+Infra/Labs work, and ensures that devs match bots.)
+
+For the above convoluted reason `get_toolchain_if_necessary` uses
+`toolchain2013.py` to extract the zip file, but the majority of the code in
+there is no longer used and what remains should be inlined into
+`get_toolchain_if_necessary` in the future.
+
+When the zip file is extracted, the mtimes of all the files, and the sha1 of the
+entire tree are saved to a local file. This allows future updates to compare
+whether the bits of the toolchain currently on disk are different than expected
+(the passed in SHA1), and if so, replace it with a toolchain with the correct
+SHA1. This is probably a bit more complicated than necessary, and again dates
+back to when the toolchain was assembled from many pieces. It could probably
+just write a stamp file with the SHA1, or just a version number, and trust that
+on future runs.
+
+Finally, it copies the json file to the location that the caller requested (the
+json file is generated during the unzip/acquire process in `toolchain2013.py`).
+
+## Building a <sha1>.zip
+
+Ignoring the `toolchain2013.py` steps to acquire a toolchain automatically from
+bits for Express, the procedure is roughly:
+- Get a clean Windows VM,
+- Install Visual Studio 2013 with updates as you want it,
+- Install Windows 8.1 SDK,
+- Run `package_from_installed.py`,
+- Upload the resulting zip file to the chrome-wintoolchain GS bucket.
+
+That script first builds a zip file of the required pieces, including generating
+a batch file corresponding to `SetEnv.cmd` or `vcvarsall.bat`. It then extracts
+that zip to a temporary location and calculates the SHA1 in the same way that
+the `depot_tools` update procedure would do, so that it knows what to rename the
+zip file to.