libv8 8.4.255.0

data/vendor/depot_tools/man/src/prep_demo_repo.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+
+NO_AUTOPREP=True
+. common_demo_functions.sh
+
+rm -rf $REMOTE
+mkdir -p $REMOTE
+cd $REMOTE
+
+set_user "remote"
+
+silent git init
+
+WS=build/whitespace_file.txt
+
+mkdir build
+cat > "$WS" <<EOF
+Copyright 2014 The Chromium Authors. All rights reserved.
+Use of this useless file is governed by a BSD-style license that can be
+found in the LICENSE file.
+
+
+This file is used for making non-code changes to trigger buildbot cycles. Make
+any modification below this line.
+
+=====================================================================
+
+Let's make a story. Add one sentence for every commit:
+
+CHÄPTER 1:
+It was a dark and blinky night; the rain fell in torrents -- except at
+occasional intervals, when it was checked by a violent gust of wind which
+swept up the streets (for it is in London that our scene lies), rattling along
+the housetops, and fiercely agitating the scanty flame of the lamps that
+struggled against the elements. A hooded figure emerged.
+
+It was a Domo-Banana.
+
+"What took you so long?", inquired his wife.
+
+Silence. Oblivious to his silence, she continued, "Did Mr. Usagi enjoy the
+waffles you brought him?" "You know him, he's not one to forego a waffle,
+no matter how burnt," he snickered.
+
+The pause was filled with the sound of compile errors.
+
+CHAPTER 2:
+The jelly was as dark as night, and just as runny.
+The Domo-Kun shuddered, remembering the way Mr. Usagi had speared his waffles
+with his fork, watching the runny jelly spread and pool across his plate,
+like the blood of a dying fawn. \"It reminds me of that time --\" he started, as
+his wife cut in quickly: \"-- please. I can't bear to hear it.\". A flury of
+images coming from the past flowed through his mind.
+EOF
+git add "$WS"
+
+c "Always output seccomp error messages to stderr"
+c "ozone: evdev: Filter devices by path"
+c "ContentView->ContentViewCore in ContentViewRenderView"
+c "linux_aura: Use system configuration for middle clicking the titlebar."
+c "[fsp] Add requestUnmount() method together with the request manager."
+c "don't use glibc-specific execinfo.h on uclibc builds"
+c "Make ReflectorImpl use mailboxes"
+
+git tag stage_1
+
+c "Change the Pica load benchmark to listen for the polymer-ready event"
+c "Remove AMD family check for the flapper crypto accelerator."
+c "Temporarily CHECK(trial) in ChromeRenderProcessObserver::OnSetFieldTrialGroup."
+
+echo -e '/Banana\ns/Banana/Kun\nwq' | silent ed "$WS"
+git add "$WS"
+set_user 'local'
+c "Fix terrible typo."
+
+set_user 'remote'
+c "Revert 255617, due to it not tracking use of the link doctor page properly."
+
+cat >> "$WS" <<EOF
+
+"You recall what happened on Mulholland drive?" The ceiling fan rotated slowly
+overhead, barely disturbing the thick cigarette smoke. No doubt was left about
+when the fan was last cleaned.
+
+There was an poignant pause.
+EOF
+git add "$WS"
+set_user 'local'
+c 'Finish chapter 2'
+
+git tag stage_2
+
+cat >> "$WS" <<EOF
+
+CHAPTER 3:
+Hilariousness! This chapter is awesome!
+EOF
+git add "$WS"
+set_user 'remote'
+c "Add best chapter2 ever!"
+
+c "Ensure FS is exited for all not-in-same-page navigations."
+c "Refactor data interchange format."

data/vendor/depot_tools/metrics.README.md

@@ -0,0 +1,101 @@
+# Why am I seeing this message?
+
+We're starting to collect metrics about how developers use gclient and other
+tools in depot\_tools to better understand the performance and failure modes of
+the tools, as well of the pain points and workflows of depot\_tools users.
+
+We will collect metrics only if you're a Googler on the corp network: If you can
+access https://cit-cli-metrics.appspot.com/should-upload, then we will collect
+metrics from you.
+
+The first ten executions of depot\_tools commands will print large warnings
+counting down to zero. When the counter hits zero, metrics collection will
+automatically begin, and depot\_tools will display large warning messages
+informing you of it. These messages will continue until you explicitly opt in or
+opt out.
+
+You can run `gclient metrics --opt-in` or `gclient metrics --opt-out` to do so.
+And you can opt-in or out at any time.
+
+Please consider opting in. It will allow us to know what features are the most
+important, what features can we deprecate, and what features should we develop
+to better cover your use case.
+
+## What metrics are you collecting?
+
+First, some words about what data we are **NOT** collecting:
+
+- We won't record any information that identifies you personally.
+- We won't record the command line flag values.
+- We won't record information about the current directory or environment flags.
+- We won't record arbitrary strings. We only collect a string if it is in the
+  list available at
+  https://source.chromium.org/chromium/infra/infra/+/master:go/src/infra/appengine/depot_tools_metrics/metrics/constants.go
+
+The metrics we're collecting are:
+
+- The time when the command was run.
+- The age of your depot\_tools checkout.
+- Your version of Python (in the format major.minor.micro).
+- Your version of Git (in the format major.minor.micro).
+- The OS of your machine (i.e. win, linux or mac).
+- The arch of your machine (e.g. x64, arm, etc).
+- The command that you ran (e.g. `gclient sync`).
+- The flag names (but not their values) that you passed to the command
+  (e.g. `--force`, `--revision`).
+- The execution time.
+- The exit code.
+- The project you're working on. We only record data about projects you can
+  fetch using depot\_tools' fetch command (e.g. Chromium, WebRTC, V8, etc)
+- The age of your project checkout.
+- What features are you using in your DEPS and .gclient files. For example:
+  - Are you setting `use_relative_paths=True`?
+  - Are you using `recursedeps`?
+- Information about the http requests that depot_tools makes:
+  - What host are we making the request to?
+    Only collected for well known hosts like chromium-review.googlesource.com.
+  - What path did we access on the server?
+    We map the path to an enum to make sure we're not collecting personally
+    identifiable information.
+    i.e. we report 'changes/' instead of 'changes/12345'
+  - What arguments were used on the request?
+    We collect only known argument names, but not their values.
+  - What known headers were present or absent?
+  - How long did the execution take?
+  - What was the response code?
+  - What HTTP method was used? (i.e. GET, PUT, POST, etc.)
+- Information about the commands that depot_tools runs:
+  - What command was executed? (i.e. git or cipd)
+  - How long did the command execute for?
+  - What argument names (but not values) were passed to the program.
+    (e.g. --checkout but not the branch name).
+  - What was the exit code?
+
+The list of all known strings we collect can be found at
+https://source.chromium.org/chromium/infra/infra/+/master:go/src/infra/appengine/depot_tools_metrics/metrics/constants.go
+
+The schema for the metrics being collected can be found at
+https://source.chromium.org/chromium/infra/infra/+/master:go/src/infra/appengine/depot_tools_metrics/schema/schema.proto
+
+## Why am I seeing this message *again*?
+
+We might want to collect additional metrics, and if so we will ask you for
+permission again.
+
+Opting in or out explicitly will stop the messages from being displayed.
+
+# How can I check if metrics are being collected?
+
+You can run `gclient metrics` and it will report if you have opted in, out, or
+not chosen for metrics collection.
+
+If you have not yet explicitly opted in or out you will see a message after
+each time we collect metrics.
+
+# How can I stop seeing this message?
+
+You will stop seeing it once you have explicitly opted in or out of depot\_tools
+metrics collection.
+
+You can run `gclient metrics --opt-in` or `gclient metrics --opt-out` to do so.
+And you can opt-in or out at any time.

data/vendor/depot_tools/metrics.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python
+# Copyright (c) 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.
+
+from __future__ import print_function
+
+import contextlib
+import functools
+import json
+import os
+import sys
+import tempfile
+import threading
+import time
+import traceback
+
+try:
+  import urllib2 as urllib
+except ImportError:  # For Py3 compatibility
+  import urllib.request as urllib
+
+import detect_host_arch
+import gclient_utils
+import metrics_utils
+import subprocess2
+
+
+DEPOT_TOOLS = os.path.dirname(os.path.abspath(__file__))
+CONFIG_FILE = os.path.join(DEPOT_TOOLS, 'metrics.cfg')
+UPLOAD_SCRIPT = os.path.join(DEPOT_TOOLS, 'upload_metrics.py')
+
+DISABLE_METRICS_COLLECTION = os.environ.get('DEPOT_TOOLS_METRICS') == '0'
+DEFAULT_COUNTDOWN = 10
+
+INVALID_CONFIG_WARNING = (
+    'WARNING: Your metrics.cfg file was invalid or nonexistent. A new one will '
+    'be created.'
+)
+PERMISSION_DENIED_WARNING = (
+    'Could not write the metrics collection config:\n\t%s\n'
+    'Metrics collection will be disabled.'
+)
+
+
+class _Config(object):
+  def __init__(self):
+    self._initialized = False
+    self._config = {}
+
+  def _ensure_initialized(self):
+    if self._initialized:
+      return
+
+    try:
+      config = json.loads(gclient_utils.FileRead(CONFIG_FILE))
+    except (IOError, ValueError):
+      config = {}
+
+    self._config = config.copy()
+
+    if 'is-googler' not in self._config:
+      # /should-upload is only accessible from Google IPs, so we only need to
+      # check if we can reach the page. An external developer would get access
+      # denied.
+      try:
+        req = urllib.urlopen(metrics_utils.APP_URL + '/should-upload')
+        self._config['is-googler'] = req.getcode() == 200
+      except (urllib.URLError, urllib.HTTPError):
+        self._config['is-googler'] = False
+
+    # Make sure the config variables we need are present, and initialize them to
+    # safe values otherwise.
+    self._config.setdefault('countdown', DEFAULT_COUNTDOWN)
+    self._config.setdefault('opt-in', None)
+    self._config.setdefault('version', metrics_utils.CURRENT_VERSION)
+
+    if config != self._config:
+      print(INVALID_CONFIG_WARNING, file=sys.stderr)
+      self._write_config()
+
+    self._initialized = True
+
+  def _write_config(self):
+    try:
+      gclient_utils.FileWrite(CONFIG_FILE, json.dumps(self._config))
+    except IOError as e:
+      print(PERMISSION_DENIED_WARNING % e, file=sys.stderr)
+      self._config['opt-in'] = False
+
+  @property
+  def version(self):
+    self._ensure_initialized()
+    return self._config['version']
+
+  @property
+  def is_googler(self):
+    self._ensure_initialized()
+    return self._config['is-googler']
+
+  @property
+  def opted_in(self):
+    self._ensure_initialized()
+    return self._config['opt-in']
+
+  @opted_in.setter
+  def opted_in(self, value):
+    self._ensure_initialized()
+    self._config['opt-in'] = value
+    self._config['version'] = metrics_utils.CURRENT_VERSION
+    self._write_config()
+
+  @property
+  def countdown(self):
+    self._ensure_initialized()
+    return self._config['countdown']
+
+  @property
+  def should_collect_metrics(self):
+    # Don't collect the metrics unless the user is a googler, the user has opted
+    # in, or the countdown has expired.
+    if not self.is_googler:
+      return False
+    if self.opted_in is False:
+      return False
+    if self.opted_in is None and self.countdown > 0:
+      return False
+    return True
+
+  def decrease_countdown(self):
+    self._ensure_initialized()
+    if self.countdown == 0:
+      return
+    self._config['countdown'] -= 1
+    if self.countdown == 0:
+      self._config['version'] = metrics_utils.CURRENT_VERSION
+    self._write_config()
+
+  def reset_config(self):
+    # Only reset countdown if we're already collecting metrics.
+    if self.should_collect_metrics:
+      self._ensure_initialized()
+      self._config['countdown'] = DEFAULT_COUNTDOWN
+      self._config['opt-in'] = None
+
+
+class MetricsCollector(object):
+  def __init__(self):
+    self._metrics_lock = threading.Lock()
+    self._reported_metrics = {}
+    self._config = _Config()
+    self._collecting_metrics = False
+    self._collect_custom_metrics = True
+
+  @property
+  def config(self):
+    return self._config
+
+  @property
+  def collecting_metrics(self):
+    return self._collecting_metrics
+
+  def add(self, name, value):
+    if self._collect_custom_metrics:
+      with self._metrics_lock:
+        self._reported_metrics[name] = value
+
+  def add_repeated(self, name, value):
+    if self._collect_custom_metrics:
+      with self._metrics_lock:
+        self._reported_metrics.setdefault(name, []).append(value)
+
+  @contextlib.contextmanager
+  def pause_metrics_collection(self):
+    collect_custom_metrics = self._collect_custom_metrics
+    self._collect_custom_metrics = False
+    try:
+      yield
+    finally:
+      self._collect_custom_metrics = collect_custom_metrics
+
+  def _upload_metrics_data(self):
+    """Upload the metrics data to the AppEngine app."""
+    # We invoke a subprocess, and use stdin.write instead of communicate(),
+    # so that we are able to return immediately, leaving the upload running in
+    # the background.
+    p = subprocess2.Popen(['vpython3', UPLOAD_SCRIPT], stdin=subprocess2.PIPE)
+    p.stdin.write(json.dumps(self._reported_metrics).encode('utf-8'))
+
+  def _collect_metrics(self, func, command_name, *args, **kwargs):
+    # If we're already collecting metrics, just execute the function.
+    # e.g. git-cl split invokes git-cl upload several times to upload each
+    # split CL.
+    if self.collecting_metrics:
+      # Don't collect metrics for this function.
+      # e.g. Don't record the arguments git-cl split passes to git-cl upload.
+      with self.pause_metrics_collection():
+        return func(*args, **kwargs)
+
+    self._collecting_metrics = True
+    self.add('metrics_version', metrics_utils.CURRENT_VERSION)
+    self.add('command', command_name)
+    try:
+      start = time.time()
+      result = func(*args, **kwargs)
+      exception = None
+    # pylint: disable=bare-except
+    except:
+      exception = sys.exc_info()
+    finally:
+      self.add('execution_time', time.time() - start)
+
+    exit_code = metrics_utils.return_code_from_exception(exception)
+    self.add('exit_code', exit_code)
+
+    # Add metrics regarding environment information.
+    self.add('timestamp', int(time.time()))
+    self.add('python_version', metrics_utils.get_python_version())
+    self.add('host_os', gclient_utils.GetMacWinOrLinux())
+    self.add('host_arch', detect_host_arch.HostArch())
+
+    depot_tools_age = metrics_utils.get_repo_timestamp(DEPOT_TOOLS)
+    if depot_tools_age is not None:
+      self.add('depot_tools_age', int(depot_tools_age))
+
+    git_version = metrics_utils.get_git_version()
+    if git_version:
+      self.add('git_version', git_version)
+
+    self._upload_metrics_data()
+    if exception:
+      gclient_utils.reraise(exception[0], exception[1], exception[2])
+    return result
+
+  def collect_metrics(self, command_name):
+    """A decorator used to collect metrics over the life of a function.
+
+    This decorator executes the function and collects metrics about the system
+    environment and the function performance.
+    """
+    def _decorator(func):
+      # Do this first so we don't have to read, and possibly create a config
+      # file.
+      if DISABLE_METRICS_COLLECTION:
+        return func
+      if not self.config.should_collect_metrics:
+        return func
+      # Otherwise, collect the metrics.
+      # Needed to preserve the __name__ and __doc__ attributes of func.
+      @functools.wraps(func)
+      def _inner(*args, **kwargs):
+        return self._collect_metrics(func, command_name, *args, **kwargs)
+      return _inner
+    return _decorator
+
+  @contextlib.contextmanager
+  def print_notice_and_exit(self):
+    """A context manager used to print the notice and terminate execution.
+
+    This decorator executes the function and prints the monitoring notice if
+    necessary. If an exception is raised, we will catch it, and print it before
+    printing the metrics collection notice.
+    This will call sys.exit() with an appropriate exit code to ensure the notice
+    is the last thing printed."""
+    # Needed to preserve the __name__ and __doc__ attributes of func.
+    try:
+      yield
+      exception = None
+    # pylint: disable=bare-except
+    except:
+      exception = sys.exc_info()
+
+    # Print the exception before the metrics notice, so that the notice is
+    # clearly visible even if gclient fails.
+    if exception:
+      if isinstance(exception[1], KeyboardInterrupt):
+        sys.stderr.write('Interrupted\n')
+      elif not isinstance(exception[1], SystemExit):
+        traceback.print_exception(*exception)
+
+    # Check if the version has changed
+    if (not DISABLE_METRICS_COLLECTION and self.config.is_googler
+        and self.config.opted_in is not False
+        and self.config.version != metrics_utils.CURRENT_VERSION):
+      metrics_utils.print_version_change(self.config.version)
+      self.config.reset_config()
+
+    # Print the notice
+    if (not DISABLE_METRICS_COLLECTION and self.config.is_googler
+        and self.config.opted_in is None):
+      metrics_utils.print_notice(self.config.countdown)
+      self.config.decrease_countdown()
+
+    sys.exit(metrics_utils.return_code_from_exception(exception))
+
+
+collector = MetricsCollector()