libv8 8.4.255.0

data/vendor/depot_tools/git_mark_merge_base.py

@@ -0,0 +1,73 @@
+#!/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.
+
+"""
+Explicitly set/remove/print the merge-base for the current branch.
+
+This manually set merge base will be a stand-in for `git merge-base` for the
+purposes of the chromium depot_tools git extensions. Passing no arguments will
+just print the effective merge base for the current branch.
+"""
+
+from __future__ import print_function
+
+import argparse
+import sys
+
+from subprocess2 import CalledProcessError
+
+from git_common import remove_merge_base, manual_merge_base, current_branch
+from git_common import get_or_create_merge_base, hash_one, upstream
+
+
+def main(argv):
+  parser = argparse.ArgumentParser(
+    description=__doc__.strip().splitlines()[0],
+    epilog=' '.join(__doc__.strip().splitlines()[1:]))
+  g = parser.add_mutually_exclusive_group()
+  g.add_argument(
+    'merge_base', nargs='?',
+    help='The new hash to use as the merge base for the current branch'
+  )
+  g.add_argument('--delete', '-d', action='store_true',
+                 help='Remove the set mark.')
+  opts = parser.parse_args(argv)
+
+  cur = current_branch()
+
+  if opts.delete:
+    try:
+      remove_merge_base(cur)
+    except CalledProcessError:
+      print('No merge base currently exists for %s.' % cur)
+    return 0
+
+  if opts.merge_base:
+    try:
+      opts.merge_base = hash_one(opts.merge_base)
+    except CalledProcessError:
+      print(
+          'fatal: could not resolve %s as a commit' % opts.merge_base,
+          file=sys.stderr)
+      return 1
+
+    manual_merge_base(cur, opts.merge_base, upstream(cur))
+
+  ret = 0
+  actual = get_or_create_merge_base(cur)
+  if opts.merge_base and opts.merge_base != actual:
+    ret = 1
+    print("Invalid merge_base %s" % opts.merge_base)
+
+  print("merge_base(%s): %s" % (cur, actual))
+  return ret
+
+
+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_nav_downstream.py

@@ -0,0 +1,69 @@
+#!/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.
+
+"""
+Checks out a downstream branch from the currently checked out branch. If there
+is more than one downstream branch, then this script will prompt you to select
+which branch.
+"""
+
+from __future__ import print_function
+
+import argparse
+import sys
+
+import gclient_utils
+from git_common import current_branch, branches, upstream, run, hash_one
+import metrics
+
+
+@metrics.collector.collect_metrics('git nav-downstream')
+def main(args):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--pick',
+                      help=(
+                          'The number to pick if this command would '
+                          'prompt'))
+  opts = parser.parse_args(args)
+
+  upfn = upstream
+  cur = current_branch()
+  if cur == 'HEAD':
+    def _upfn(b):
+      parent = upstream(b)
+      if parent:
+        return hash_one(parent)
+    upfn = _upfn
+    cur = hash_one(cur)
+  downstreams = [b for b in branches() if upfn(b) == cur]
+  if not downstreams:
+    print("No downstream branches")
+    return 1
+  elif len(downstreams) == 1:
+    run('checkout', downstreams[0], stdout=sys.stdout, stderr=sys.stderr)
+  else:
+    high = len(downstreams) - 1
+    while True:
+      print("Please select a downstream branch")
+      for i, b in enumerate(downstreams):
+        print("  %d. %s" % (i, b))
+      prompt = "Selection (0-%d)[0]: " % high
+      r = opts.pick
+      if r:
+        print(prompt + r)
+      else:
+        r = gclient_utils.AskForData(prompt).strip() or '0'
+      if not r.isdigit() or (0 > int(r) > high):
+        print("Invalid choice.")
+      else:
+        run('checkout', downstreams[int(r)], stdout=sys.stdout,
+            stderr=sys.stderr)
+        break
+  return 0
+
+
+if __name__ == '__main__':
+  with metrics.collector.print_notice_and_exit():
+    sys.exit(main(sys.argv[1:]))

data/vendor/depot_tools/git_new_branch.py

@@ -0,0 +1,82 @@
+#!/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.
+"""
+Create new branch tracking origin/master by default.
+"""
+
+import argparse
+import sys
+
+import git_common
+import subprocess2
+
+
+def create_new_branch(
+    branch_name, upstream_current=False, upstream=None, inject_current=False):
+  upstream = upstream or git_common.root()
+  try:
+    if inject_current:
+      below = git_common.current_branch()
+      if below is None:
+        raise Exception('no current branch')
+      above = git_common.upstream(below)
+      if above is None:
+        raise Exception('branch %s has no upstream' % (below))
+      git_common.run('checkout', '--track', above, '-b', branch_name)
+      git_common.run('branch', '--set-upstream-to', branch_name, below)
+    elif upstream_current:
+      git_common.run('checkout', '--track', '-b', branch_name)
+    else:
+      if upstream in git_common.tags():
+        # TODO(iannucci): ensure that basis_ref is an ancestor of HEAD?
+        git_common.run(
+            'checkout', '--no-track', '-b', branch_name,
+            git_common.hash_one(upstream))
+        git_common.set_config('branch.%s.remote' % branch_name, '.')
+        git_common.set_config('branch.%s.merge' % branch_name, upstream)
+      else:
+        # TODO(iannucci): Detect unclean workdir then stash+pop if we need to
+        # teleport to a conflicting portion of history?
+        git_common.run('checkout', '--track', upstream, '-b', branch_name)
+    git_common.get_or_create_merge_base(branch_name)
+  except subprocess2.CalledProcessError as cpe:
+    sys.stdout.write(cpe.stdout.decode('utf-8', 'replace'))
+    sys.stderr.write(cpe.stderr.decode('utf-8', 'replace'))
+    return 1
+  sys.stderr.write('Switched to branch %s.\n' % branch_name)
+  return 0
+
+def main(args):
+  parser = argparse.ArgumentParser(
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    description=__doc__,
+  )
+  parser.add_argument('branch_name')
+  g = parser.add_mutually_exclusive_group()
+  g.add_argument('--upstream-current', '--upstream_current',
+                 action='store_true',
+                 help='set upstream branch to current branch.')
+  g.add_argument('--upstream', metavar='REF',
+                 help='upstream branch (or tag) to track.')
+  g.add_argument('--inject-current', '--inject_current',
+                 action='store_true',
+                 help='new branch adopts current branch\'s upstream,' +
+                 ' and new branch becomes current branch\'s upstream.')
+  g.add_argument('--lkgr', action='store_const', const='lkgr', dest='upstream',
+                 help='set basis ref for new branch to lkgr.')
+
+  opts = parser.parse_args(args)
+
+  return create_new_branch(
+      opts.branch_name, opts.upstream_current, opts.upstream,
+      opts.inject_current)
+
+
+if __name__ == '__main__':  # pragma: no cover
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)

data/vendor/depot_tools/git_number.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env vpython3
+# 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.
+
+"""Usage: %prog [options] [<commitref>]*
+
+If no <commitref>'s are supplied, it defaults to HEAD.
+
+Calculates the generation number for one or more commits in a git repo.
+
+Generation number of a commit C with parents P is defined as:
+  generation_number(C, []) = 0
+  generation_number(C, P)  = max(map(generation_number, P)) + 1
+
+This number can be used to order commits relative to each other, as long as for
+any pair of the commits, one is an ancestor of the other.
+
+Since calculating the generation number of a commit requires walking that
+commit's entire history, this script caches all calculated data inside the git
+repo that it operates on in the ref 'refs/number/commits'.
+"""
+
+from __future__ import print_function
+from __future__ import division
+
+import binascii
+import collections
+import logging
+import optparse
+import os
+import struct
+import sys
+import tempfile
+
+import git_common as git
+import subprocess2
+
+CHUNK_FMT = '!20sL'
+CHUNK_SIZE = struct.calcsize(CHUNK_FMT)
+DIRTY_TREES = collections.defaultdict(int)
+REF = 'refs/number/commits'
+AUTHOR_NAME = 'git-number'
+AUTHOR_EMAIL = 'chrome-infrastructure-team@google.com'
+
+# Number of bytes to use for the prefix on our internal number structure.
+# 0 is slow to deserialize. 2 creates way too much bookkeeping overhead (would
+# need to reimplement cache data structures to be a bit more sophisticated than
+# dicts. 1 seems to be just right.
+PREFIX_LEN = 1
+
+# Set this to 'threads' to gather coverage data while testing.
+POOL_KIND = 'procs'
+
+
+def pathlify(hash_prefix):
+  """Converts a binary object hash prefix into a posix path, one folder per
+  byte.
+
+  >>> pathlify('\xDE\xAD')
+  'de/ad'
+  """
+  if sys.version_info.major == 3:
+    return '/'.join('%02x' % b for b in hash_prefix)
+  else:
+    return '/'.join('%02x' % ord(b) for b in hash_prefix)
+
+
+@git.memoize_one(threadsafe=False)
+def get_number_tree(prefix_bytes):
+  """Returns a dictionary of the git-number registry specified by
+  |prefix_bytes|.
+
+  This is in the form of {<full binary ref>: <gen num> ...}
+
+  >>> get_number_tree('\x83\xb4')
+  {'\x83\xb4\xe3\xe4W\xf9J*\x8f/c\x16\xecD\xd1\x04\x8b\xa9qz': 169, ...}
+  """
+  ref = '%s:%s' % (REF, pathlify(prefix_bytes))
+
+  try:
+    raw = git.run('cat-file', 'blob', ref, autostrip=False, decode=False)
+    return dict(struct.unpack_from(CHUNK_FMT, raw, i * CHUNK_SIZE)
+                for i in range(len(raw) // CHUNK_SIZE))
+  except subprocess2.CalledProcessError:
+    return {}
+
+
+@git.memoize_one(threadsafe=False)
+def get_num(commit_hash):
+  """Returns the generation number for a commit.
+
+  Returns None if the generation number for this commit hasn't been calculated
+  yet (see load_generation_numbers()).
+  """
+  return get_number_tree(commit_hash[:PREFIX_LEN]).get(commit_hash)
+
+
+def clear_caches(on_disk=False):
+  """Clears in-process caches for e.g. unit testing."""
+  get_number_tree.clear()
+  get_num.clear()
+  if on_disk:
+    git.run('update-ref', '-d', REF)
+
+
+def intern_number_tree(tree):
+  """Transforms a number tree (in the form returned by |get_number_tree|) into
+  a git blob.
+
+  Returns the git blob id as hex-encoded string.
+
+  >>> d = {'\x83\xb4\xe3\xe4W\xf9J*\x8f/c\x16\xecD\xd1\x04\x8b\xa9qz': 169}
+  >>> intern_number_tree(d)
+  'c552317aa95ca8c3f6aae3357a4be299fbcb25ce'
+  """
+  with tempfile.TemporaryFile() as f:
+    for k, v in sorted(tree.items()):
+      f.write(struct.pack(CHUNK_FMT, k, v))
+    f.seek(0)
+    return git.intern_f(f)
+
+
+def leaf_map_fn(pre_tree):
+  """Converts a prefix and number tree into a git index line."""
+  pre, tree = pre_tree
+  return '100644 blob %s\t%s\0' % (intern_number_tree(tree), pathlify(pre))
+
+
+def finalize(targets):
+  """Saves all cache data to the git repository.
+
+  After calculating the generation number for |targets|, call finalize() to
+  save all the work to the git repository.
+
+  This in particular saves the trees referred to by DIRTY_TREES.
+  """
+  if not DIRTY_TREES:
+    return
+
+  msg = 'git-number Added %s numbers' % sum(DIRTY_TREES.values())
+
+  idx = os.path.join(git.run('rev-parse', '--git-dir'), 'number.idx')
+  env = os.environ.copy()
+  env['GIT_INDEX_FILE'] = str(idx)
+
+  progress_message = 'Finalizing: (%%(count)d/%d)' % len(DIRTY_TREES)
+  with git.ProgressPrinter(progress_message) as inc:
+    git.run('read-tree', REF, env=env)
+
+    prefixes_trees = ((p, get_number_tree(p)) for p in sorted(DIRTY_TREES))
+    updater = subprocess2.Popen(['git', 'update-index', '-z', '--index-info'],
+                                stdin=subprocess2.PIPE, env=env)
+
+    with git.ScopedPool(kind=POOL_KIND) as leaf_pool:
+      for item in leaf_pool.imap(leaf_map_fn, prefixes_trees):
+        updater.stdin.write(item.encode())
+        inc()
+
+    updater.stdin.close()
+    updater.wait()
+    assert updater.returncode == 0
+
+    tree_id = git.run('write-tree', env=env)
+    commit_cmd = [
+        # Git user.name and/or user.email may not be configured, so specifying
+        # them explicitly. They are not used, but required by Git.
+        '-c', 'user.name=%s' % AUTHOR_NAME,
+        '-c', 'user.email=%s' % AUTHOR_EMAIL,
+        'commit-tree',
+        '-m', msg,
+        '-p'] + git.hash_multi(REF)
+    for t in targets:
+      commit_cmd.extend(['-p', binascii.hexlify(t).decode()])
+    commit_cmd.append(tree_id)
+    commit_hash = git.run(*commit_cmd)
+    git.run('update-ref', REF, commit_hash)
+  DIRTY_TREES.clear()
+
+
+def preload_tree(prefix):
+  """Returns the prefix and parsed tree object for the specified prefix."""
+  return prefix, get_number_tree(prefix)
+
+
+def all_prefixes(depth=PREFIX_LEN):
+  if sys.version_info.major == 3:
+    prefixes = [bytes([i]) for i in range(255)]
+  else:
+    prefixes = [chr(i) for i in range(255)]
+  for x in prefixes:
+    # This isn't covered because PREFIX_LEN currently == 1
+    if depth > 1:  # pragma: no cover
+      for r in all_prefixes(depth - 1):
+        yield x + r
+    else:
+      yield x
+
+
+def load_generation_numbers(targets):
+  """Populates the caches of get_num and get_number_tree so they contain
+  the results for |targets|.
+
+  Loads cached numbers from disk, and calculates missing numbers if one or
+  more of |targets| is newer than the cached calculations.
+
+  Args:
+    targets - An iterable of binary-encoded full git commit hashes.
+  """
+  # In case they pass us a generator, listify targets.
+  targets = list(targets)
+
+  if all(get_num(t) is not None for t in targets):
+    return
+
+  if git.tree(REF) is None:
+    empty = git.mktree({})
+    commit_hash = git.run(
+        # Git user.name and/or user.email may not be configured, so specifying
+        # them explicitly. They are not used, but required by Git.
+        '-c', 'user.name=%s' % AUTHOR_NAME,
+        '-c', 'user.email=%s' % AUTHOR_EMAIL,
+        'commit-tree',
+        '-m', 'Initial commit from git-number',
+        empty)
+    git.run('update-ref', REF, commit_hash)
+
+  with git.ScopedPool(kind=POOL_KIND) as pool:
+    preload_iter = pool.imap_unordered(preload_tree, all_prefixes())
+
+    rev_list = []
+
+    with git.ProgressPrinter('Loading commits: %(count)d') as inc:
+      # Curiously, buffering the list into memory seems to be the fastest
+      # approach in python (as opposed to iterating over the lines in the
+      # stdout as they're produced). GIL strikes again :/
+      cmd = [
+        'rev-list', '--topo-order', '--parents', '--reverse', '^' + REF,
+      ] + [binascii.hexlify(target).decode() for target in targets]
+      for line in git.run(*cmd).splitlines():
+        tokens = [binascii.unhexlify(token) for token in line.split()]
+        rev_list.append((tokens[0], tokens[1:]))
+        inc()
+
+    get_number_tree.update(preload_iter)
+
+  with git.ProgressPrinter('Counting: %%(count)d/%d' % len(rev_list)) as inc:
+    for commit_hash, pars in rev_list:
+      num = max(map(get_num, pars)) + 1 if pars else 0
+
+      prefix = commit_hash[:PREFIX_LEN]
+      get_number_tree(prefix)[commit_hash] = num
+      DIRTY_TREES[prefix] += 1
+      get_num.set(commit_hash, num)
+
+      inc()
+
+
+def main():  # pragma: no cover
+  parser = optparse.OptionParser(usage=sys.modules[__name__].__doc__)
+  parser.add_option('--no-cache', action='store_true',
+                    help='Do not actually cache anything we calculate.')
+  parser.add_option('--reset', action='store_true',
+                    help='Reset the generation number cache and quit.')
+  parser.add_option('-v', '--verbose', action='count', default=0,
+                    help='Be verbose. Use more times for more verbosity.')
+  opts, args = parser.parse_args()
+
+  levels = [logging.ERROR, logging.INFO, logging.DEBUG]
+  logging.basicConfig(level=levels[min(opts.verbose, len(levels) - 1)])
+
+  # 'git number' should only be used on bots.
+  if os.getenv('CHROME_HEADLESS') != '1':
+    logging.error("'git-number' is an infrastructure tool that is only "
+                  "intended to be used internally by bots. Developers should "
+                  "use the 'Cr-Commit-Position' value in the commit's message.")
+    return 1
+
+  if opts.reset:
+    clear_caches(on_disk=True)
+    return
+
+  try:
+    targets = git.parse_commitrefs(*(args or ['HEAD']))
+  except git.BadCommitRefException as e:
+    parser.error(e)
+
+  load_generation_numbers(targets)
+  if not opts.no_cache:
+    finalize(targets)
+
+  print('\n'.join(map(str, map(get_num, targets))))
+  return 0
+
+
+if __name__ == '__main__':  # pragma: no cover
+  try:
+    sys.exit(main())
+  except KeyboardInterrupt:
+    sys.stderr.write('interrupted\n')
+    sys.exit(1)