libv8 8.4.255.0

data/vendor/depot_tools/git_retry.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+# 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.
+
+
+"""Generic retry wrapper for Git operations. 
+
+This is largely DEPRECATED in favor of the Infra Git wrapper:
+https://chromium.googlesource.com/infra/infra/+/master/go/src/infra/tools/git
+"""
+
+import logging
+import optparse
+import os
+import subprocess
+import sys
+import threading
+import time
+
+from git_common import GIT_EXE, GIT_TRANSIENT_ERRORS_RE
+
+
+class TeeThread(threading.Thread):
+
+  def __init__(self, fd, out_fd, name):
+    super(TeeThread, self).__init__(name='git-retry.tee.%s' % (name,))
+    self.data = None
+    self.fd = fd
+    self.out_fd = out_fd
+
+  def run(self):
+    chunks = []
+    for line in self.fd:
+      chunks.append(line)
+      self.out_fd.write(line)
+    self.data = ''.join(chunks)
+
+
+class GitRetry(object):
+
+  logger = logging.getLogger('git-retry')
+  DEFAULT_DELAY_SECS = 3.0
+  DEFAULT_RETRY_COUNT = 5
+
+  def __init__(self, retry_count=None, delay=None, delay_factor=None):
+    self.retry_count = retry_count or self.DEFAULT_RETRY_COUNT
+    self.delay = max(delay, 0) if delay else 0
+    self.delay_factor = max(delay_factor, 0) if delay_factor else 0
+
+  def shouldRetry(self, stderr):
+    m = GIT_TRANSIENT_ERRORS_RE.search(stderr)
+    if not m:
+      return False
+    self.logger.info("Encountered known transient error: [%s]",
+                     stderr[m.start(): m.end()])
+    return True
+
+  @staticmethod
+  def execute(*args):
+    args = (GIT_EXE,) + args
+    proc = subprocess.Popen(
+        args,
+        stderr=subprocess.PIPE,
+    )
+    stderr_tee = TeeThread(proc.stderr, sys.stderr, 'stderr')
+
+    # Start our process. Collect/tee 'stdout' and 'stderr'.
+    stderr_tee.start()
+    try:
+      proc.wait()
+    except KeyboardInterrupt:
+      proc.kill()
+      raise
+    finally:
+      stderr_tee.join()
+    return proc.returncode, None, stderr_tee.data
+
+  def computeDelay(self, iteration):
+    """Returns: the delay (in seconds) for a given iteration
+
+    The first iteration has a delay of '0'.
+
+    Args:
+      iteration: (int) The iteration index (starting with zero as the first
+          iteration)
+    """
+    if (not self.delay) or (iteration == 0):
+      return 0
+    if self.delay_factor == 0:
+      # Linear delay
+      return iteration * self.delay
+    # Exponential delay
+    return (self.delay_factor ** (iteration - 1)) * self.delay
+
+  def __call__(self, *args):
+    returncode = 0
+    for i in xrange(self.retry_count):
+      # If the previous run failed and a delay is configured, delay before the
+      # next run.
+      delay = self.computeDelay(i)
+      if delay > 0:
+        self.logger.info("Delaying for [%s second(s)] until next retry", delay)
+        time.sleep(delay)
+
+      self.logger.debug("Executing subprocess (%d/%d) with arguments: %s",
+                        (i+1), self.retry_count, args)
+      returncode, _, stderr = self.execute(*args)
+
+      self.logger.debug("Process terminated with return code: %d", returncode)
+      if returncode == 0:
+        break
+
+      if not self.shouldRetry(stderr):
+        self.logger.error("Process failure was not known to be transient; "
+                          "terminating with return code %d", returncode)
+        break
+    return returncode
+
+
+def main(args):
+  # If we're using the Infra Git wrapper, do nothing here.
+  # https://chromium.googlesource.com/infra/infra/+/master/go/src/infra/tools/git
+  if 'INFRA_GIT_WRAPPER' in os.environ:
+    # Remove Git's execution path from PATH so that our call-through re-invokes
+    # the Git wrapper.
+    # See crbug.com/721450
+    env = os.environ.copy()
+    git_exec = subprocess.check_output([GIT_EXE, '--exec-path']).strip()
+    env['PATH'] = os.pathsep.join([
+      elem for elem in env.get('PATH', '').split(os.pathsep)
+      if elem != git_exec])
+    return subprocess.call([GIT_EXE] + args, env=env)
+
+  parser = optparse.OptionParser()
+  parser.disable_interspersed_args()
+  parser.add_option('-v', '--verbose',
+                    action='count', default=0,
+                    help="Increase verbosity; can be specified multiple times")
+  parser.add_option('-c', '--retry-count', metavar='COUNT',
+                    type=int, default=GitRetry.DEFAULT_RETRY_COUNT,
+                    help="Number of times to retry (default=%default)")
+  parser.add_option('-d', '--delay', metavar='SECONDS',
+                    type=float, default=GitRetry.DEFAULT_DELAY_SECS,
+                    help="Specifies the amount of time (in seconds) to wait "
+                         "between successive retries (default=%default). This "
+                         "can be zero.")
+  parser.add_option('-D', '--delay-factor', metavar='FACTOR',
+                    type=int, default=2,
+                    help="The exponential factor to apply to delays in between "
+                         "successive failures (default=%default). If this is "
+                         "zero, delays will increase linearly. Set this to "
+                         "one to have a constant (non-increasing) delay.")
+
+  opts, args = parser.parse_args(args)
+
+  # Configure logging verbosity
+  if opts.verbose == 0:
+    logging.getLogger().setLevel(logging.WARNING)
+  elif opts.verbose == 1:
+    logging.getLogger().setLevel(logging.INFO)
+  else:
+    logging.getLogger().setLevel(logging.DEBUG)
+
+  # Execute retries
+  retry = GitRetry(
+      retry_count=opts.retry_count,
+      delay=opts.delay,
+      delay_factor=opts.delay_factor,
+  )
+  return retry(*args)
+
+
+if __name__ == '__main__':
+  logging.basicConfig()
+  logging.getLogger().setLevel(logging.WARNING)
+  try:
+    sys.exit(main(sys.argv[2:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_squash_branch.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# 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.
+
+import argparse
+import sys
+
+import git_common
+
+def main(args):
+  parser = argparse.ArgumentParser()
+  parser.add_argument(
+      '-m', '--message', metavar='<msg>', default=None,
+      help='Use the given <msg> as the first line of the commit message.')
+  opts = parser.parse_args(args)
+  if git_common.is_dirty_git_tree('squash-branch'):
+    return 1
+  git_common.squash_current_branch(opts.message)
+  return 0
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_upstream_diff.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# 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.
+
+from __future__ import print_function
+
+import argparse
+import sys
+
+import subprocess2
+
+import git_common as git
+
+def main(args):
+  default_args = git.get_config_list('depot-tools.upstream-diff.default-args')
+  args = default_args + args
+
+  current_branch = git.current_branch()
+
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--wordwise', action='store_true', default=False,
+                      help=(
+                        'Print a colorized wordwise diff '
+                        'instead of line-wise diff'))
+  parser.add_argument('--branch', default=current_branch,
+                      help='Show changes from a different branch. Passing '
+                           '"HEAD" is the same as omitting this option (it '
+                           'diffs against the current branch)')
+  opts, extra_args = parser.parse_known_args(args)
+
+  if opts.branch == 'HEAD':
+    opts.branch = current_branch
+
+  if not opts.branch or opts.branch == 'HEAD':
+    print('fatal: Cannot perform git-upstream-diff while not on a branch')
+    return 1
+
+  par = git.upstream(opts.branch)
+  if not par:
+    print('fatal: No upstream configured for branch \'%s\'' % opts.branch)
+    return 1
+
+  cmd = [git.GIT_EXE, '-c', 'core.quotePath=false',
+         'diff', '--patience', '-C', '-C']
+  if opts.wordwise:
+    cmd += ['--word-diff=color', r'--word-diff-regex=(\w+|[^[:space:]])']
+  cmd += [git.get_or_create_merge_base(opts.branch, par)]
+  # Only specify the end commit if it is not the current branch, this lets the
+  # diff include uncommitted changes when diffing the current branch.
+  if opts.branch != current_branch:
+    cmd += [opts.branch]
+
+  cmd += extra_args
+
+  return subprocess2.check_call(cmd)
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/gn

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# 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.
+
+base_dir=$(dirname "$0")
+
+PYTHONDONTWRITEBYTECODE=1 exec python "$base_dir/gn.py" "$@"

data/vendor/depot_tools/gn.bat

@@ -0,0 +1,12 @@
+@echo off
+:: 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.
+setlocal
+
+:: Ensure that "depot_tools" is somewhere in PATH so this tool can be used
+:: standalone, but allow other PATH manipulations to take priority.
+set PATH=%PATH%;%~dp0
+
+:: Defer control.
+python "%~dp0\gn.py" %*

data/vendor/depot_tools/gn.py

@@ -0,0 +1,78 @@
+#!/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.
+
+"""This script is a wrapper around the GN binary that is pulled from Google
+Cloud Storage when you sync Chrome. The binaries go into platform-specific
+subdirectories in the source tree.
+
+This script makes there be one place for forwarding to the correct platform's
+binary. It will also automatically try to find the gn binary when run inside
+the chrome source tree, so users can just type "gn" on the command line
+(normally depot_tools is on the path)."""
+
+from __future__ import print_function
+
+import gclient_paths
+import os
+import subprocess
+import sys
+
+
+def PruneVirtualEnv():
+  # Set by VirtualEnv, no need to keep it.
+  os.environ.pop('VIRTUAL_ENV', None)
+
+  # Set by VPython, if scripts want it back they have to set it explicitly.
+  os.environ.pop('PYTHONNOUSERSITE', None)
+
+  # Look for "activate_this.py" in this path, which is installed by VirtualEnv.
+  # This mechanism is used by vpython as well to sanitize VirtualEnvs from
+  # $PATH.
+  os.environ['PATH'] = os.pathsep.join([
+    p for p in os.environ.get('PATH', '').split(os.pathsep)
+    if not os.path.isfile(os.path.join(p, 'activate_this.py'))
+  ])
+
+
+def main(args):
+  # Prune all evidence of VPython/VirtualEnv out of the environment. This means
+  # that we 'unwrap' vpython VirtualEnv path/env manipulation. Invocations of
+  # `python` from GN should never inherit the gn.py's own VirtualEnv. This also
+  # helps to ensure that generated ninja files do not reference python.exe from
+  # the VirtualEnv generated from depot_tools' own .vpython file (or lack
+  # thereof), but instead reference the default python from the PATH.
+  PruneVirtualEnv()
+
+  # Try in primary solution location first, with the gn binary having been
+  # downloaded by cipd in the projects DEPS.
+  primary_solution_path = gclient_paths.GetPrimarySolutionPath()
+  if primary_solution_path:
+    gn_path = os.path.join(primary_solution_path, 'third_party',
+                           'gn', 'gn' + gclient_paths.GetExeSuffix())
+    if os.path.exists(gn_path):
+      return subprocess.call([gn_path] + args[1:])
+
+  # Otherwise try the old .sha1 and download_from_google_storage locations
+  # inside of buildtools.
+  bin_path = gclient_paths.GetBuildtoolsPlatformBinaryPath()
+  if not bin_path:
+    print('gn.py: Could not find checkout in any parent of the current path.\n'
+          'This must be run inside a checkout.', file=sys.stderr)
+    return 1
+  gn_path = os.path.join(bin_path, 'gn' + gclient_paths.GetExeSuffix())
+  if not os.path.exists(gn_path):
+    print(
+        'gn.py: Could not find gn executable at: %s' % gn_path, file=sys.stderr)
+    return 2
+  else:
+    return subprocess.call([gn_path] + args[1:])
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/goma_auth

@@ -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
+
+PYTHONDONTWRITEBYTECODE=1 exec python "$MYPATH/.cipd_bin/goma_auth.py" "$@"

data/vendor/depot_tools/goma_auth.bat

@@ -0,0 +1,8 @@
+@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
+@call python.bat %~dp0\.cipd_bin\goma_auth.py %*
+exit /b

data/vendor/depot_tools/goma_ctl

@@ -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
+
+PYTHONDONTWRITEBYTECODE=1 exec vpython "$MYPATH/.cipd_bin/goma_ctl.py" "$@"

data/vendor/depot_tools/goma_ctl.bat

@@ -0,0 +1,8 @@
+@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
+@call vpython.bat %~dp0\.cipd_bin\goma_ctl.py %*
+exit /b

data/vendor/depot_tools/gsutil.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+# 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.
+
+"""Run a pinned gsutil."""
+
+
+import argparse
+import base64
+import contextlib
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+try:
+  import urllib2 as urllib
+except ImportError:  # For Py3 compatibility
+  import urllib.request as urllib
+
+import zipfile
+
+
+GSUTIL_URL = 'https://storage.googleapis.com/pub/'
+API_URL = 'https://www.googleapis.com/storage/v1/b/pub/o/'
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_BIN_DIR = os.path.join(THIS_DIR, 'external_bin', 'gsutil')
+DEFAULT_FALLBACK_GSUTIL = os.path.join(
+    THIS_DIR, 'third_party', 'gsutil', 'gsutil')
+
+IS_WINDOWS = os.name == 'nt'
+
+
+class InvalidGsutilError(Exception):
+  pass
+
+
+def download_gsutil(version, target_dir):
+  """Downloads gsutil into the target_dir."""
+  filename = 'gsutil_%s.zip' % version
+  target_filename = os.path.join(target_dir, filename)
+
+  # Check if the target exists already.
+  if os.path.exists(target_filename):
+    md5_calc = hashlib.md5()
+    with open(target_filename, 'rb') as f:
+      while True:
+        buf = f.read(4096)
+        if not buf:
+          break
+        md5_calc.update(buf)
+    local_md5 = md5_calc.hexdigest()
+
+    metadata_url = '%s%s' % (API_URL, filename)
+    metadata = json.load(urllib.urlopen(metadata_url))
+    remote_md5 = base64.b64decode(metadata['md5Hash']).decode('utf-8')
+
+    if local_md5 == remote_md5:
+      return target_filename
+    os.remove(target_filename)
+
+  # Do the download.
+  url = '%s%s' % (GSUTIL_URL, filename)
+  u = urllib.urlopen(url)
+  with open(target_filename, 'wb') as f:
+    while True:
+      buf = u.read(4096)
+      if not buf:
+        break
+      f.write(buf)
+  return target_filename
+
+
+@contextlib.contextmanager
+def temporary_directory(base):
+  tmpdir = tempfile.mkdtemp(prefix='gsutil_py', dir=base)
+  try:
+    yield tmpdir
+  finally:
+    if os.path.isdir(tmpdir):
+      shutil.rmtree(tmpdir)
+
+
+def ensure_gsutil(version, target, clean):
+  bin_dir = os.path.join(target, 'gsutil_%s' % version)
+  gsutil_bin = os.path.join(bin_dir, 'gsutil', 'gsutil')
+  gsutil_flag = os.path.join(bin_dir, 'gsutil', 'install.flag')
+  # We assume that if gsutil_flag exists, then we have a good version
+  # of the gsutil package.
+  if not clean and os.path.isfile(gsutil_flag):
+    # Everything is awesome! we're all done here.
+    return gsutil_bin
+
+  if not os.path.exists(target):
+    os.makedirs(target)
+  with temporary_directory(target) as instance_dir:
+    # Clean up if we're redownloading a corrupted gsutil.
+    cleanup_path = os.path.join(instance_dir, 'clean')
+    try:
+      os.rename(bin_dir, cleanup_path)
+    except (OSError, IOError):
+      cleanup_path = None
+    if cleanup_path:
+      shutil.rmtree(cleanup_path)
+
+    download_dir = os.path.join(instance_dir, 'download')
+    target_zip_filename = download_gsutil(version, instance_dir)
+    with zipfile.ZipFile(target_zip_filename, 'r') as target_zip:
+      target_zip.extractall(download_dir)
+
+    try:
+      os.rename(download_dir, bin_dir)
+    except (OSError, IOError):
+      # Something else did this in parallel.
+      pass
+    # Final check that the gsutil bin exists.  This should never fail.
+    if not os.path.isfile(gsutil_bin):
+      raise InvalidGsutilError()
+    # Drop a flag file.
+    with open(gsutil_flag, 'w') as f:
+      f.write('This flag file is dropped by gsutil.py')
+
+  return gsutil_bin
+
+
+def run_gsutil(force_version, fallback, target, args, clean=False):
+  if force_version:
+    gsutil_bin = ensure_gsutil(force_version, target, clean)
+  else:
+    gsutil_bin = fallback
+  disable_update = ['-o', 'GSUtil:software_update_check_period=0']
+
+  if sys.platform == 'cygwin':
+    # This script requires Windows Python, so invoke with depot_tools'
+    # Python.
+    def winpath(path):
+      stdout = subprocess.check_output(['cygpath', '-w', path])
+      return stdout.strip().decode('utf-8', 'replace')
+    cmd = ['python.bat', winpath(__file__)]
+    cmd.extend(args)
+    sys.exit(subprocess.call(cmd))
+  assert sys.platform != 'cygwin'
+
+  # Run "gsutil" through "vpython". We need to do this because on GCE instances,
+  # expectations are made about Python having access to "google-compute-engine"
+  # and "boto" packages that are not met with non-system Python (e.g., bundles).
+  cmd = [
+      'vpython',
+      '-vpython-spec', os.path.join(THIS_DIR, 'gsutil.vpython'),
+      '--',
+      gsutil_bin
+  ] + disable_update + args
+  return subprocess.call(cmd, shell=IS_WINDOWS)
+
+
+def parse_args():
+  bin_dir = os.environ.get('DEPOT_TOOLS_GSUTIL_BIN_DIR', DEFAULT_BIN_DIR)
+
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--force-version', default='4.30')
+  parser.add_argument('--clean', action='store_true',
+      help='Clear any existing gsutil package, forcing a new download.')
+  parser.add_argument('--fallback', default=DEFAULT_FALLBACK_GSUTIL)
+  parser.add_argument('--target', default=bin_dir,
+      help='The target directory to download/store a gsutil version in. '
+           '(default is %(default)s).')
+  parser.add_argument('args', nargs=argparse.REMAINDER)
+
+  args, extras = parser.parse_known_args()
+  if args.args and args.args[0] == '--':
+    args.args.pop(0)
+  if extras:
+    args.args = extras + args.args
+  return args
+
+
+def main():
+  args = parse_args()
+  return run_gsutil(args.force_version, args.fallback, args.target, args.args,
+                    clean=args.clean)
+
+
+if __name__ == '__main__':
+  sys.exit(main())