libv8 8.4.255.0

data/vendor/depot_tools/setup_color.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# Copyright (c) 2016 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 ctypes
+import os
+import platform
+import subprocess
+import sys
+from third_party import colorama
+
+IS_TTY = None
+OUT_TYPE = 'unknown'
+
+
+def enable_native_ansi():
+  """Enables native ANSI sequences in console. Windows 10 only.
+
+  Returns whether successful.
+  """
+  kernel32 = ctypes.windll.kernel32
+  ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x04
+
+  out_handle = kernel32.GetStdHandle(subprocess.STD_OUTPUT_HANDLE)
+
+  # GetConsoleMode fails if the terminal isn't native.
+  mode = ctypes.wintypes.DWORD()
+  if kernel32.GetConsoleMode(out_handle, ctypes.byref(mode)) == 0:
+    return False
+
+  if not (mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING):
+    if kernel32.SetConsoleMode(
+        out_handle, mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING) == 0:
+      print(
+          'kernel32.SetConsoleMode to enable ANSI sequences failed',
+          file=sys.stderr)
+      return False
+
+  return True
+
+
+def init():
+  # should_wrap instructs colorama to wrap stdout/stderr with an ASNI colorcode
+  # interpreter that converts them to SetConsoleTextAttribute calls. This only
+  # should be True in cases where we're connected to cmd.exe's console. Setting
+  # this to True on non-windows systems has no effect.
+  should_wrap = False
+  global IS_TTY, OUT_TYPE
+  IS_TTY = sys.stdout.isatty()
+  if IS_TTY:
+    # Yay! We detected a console in the normal way. It doesn't really matter
+    # if it's windows or not, we win.
+    OUT_TYPE = 'console'
+    should_wrap = True
+  elif sys.platform.startswith('win'):
+    # assume this is some sort of file
+    OUT_TYPE = 'file (win)'
+
+    import msvcrt
+    h = msvcrt.get_osfhandle(sys.stdout.fileno())
+    # h is the win32 HANDLE for stdout.
+    ftype = ctypes.windll.kernel32.GetFileType(h)
+    if ftype == 2: # FILE_TYPE_CHAR
+      # This is a normal cmd console, but we'll only get here if we're running
+      # inside a `git command` which is actually git->bash->command. Not sure
+      # why isatty doesn't detect this case.
+      OUT_TYPE = 'console (cmd via msys)'
+      IS_TTY = True
+      should_wrap = True
+    elif ftype == 3: # FILE_TYPE_PIPE
+      OUT_TYPE = 'pipe (win)'
+      # This is some kind of pipe on windows. This could either be a real pipe
+      # or this could be msys using a pipe to emulate a pty. We use the same
+      # algorithm that msys-git uses to determine if it's connected to a pty or
+      # not.
+
+      # This function and the structures are defined in the MSDN documentation
+      # using the same names.
+      def NT_SUCCESS(status):
+        # The first two bits of status are the severity. The success
+        # severities are 0 and 1, and the !success severities are 2 and 3.
+        # Therefore since ctypes interprets the default restype of the call
+        # to be an 'C int' (which is guaranteed to be signed 32 bits), All
+        # success codes are positive, and all !success codes are negative.
+        return status >= 0
+
+      class UNICODE_STRING(ctypes.Structure):
+        _fields_ = [('Length', ctypes.c_ushort),
+                    ('MaximumLength', ctypes.c_ushort),
+                    ('Buffer', ctypes.c_wchar_p)]
+
+      class OBJECT_NAME_INFORMATION(ctypes.Structure):
+        _fields_ = [('Name', UNICODE_STRING),
+                    ('NameBuffer', ctypes.c_wchar_p)]
+
+      buf = ctypes.create_string_buffer(1024)
+      # Ask NT what the name of the object our stdout HANDLE is. It would be
+      # possible to use GetFileInformationByHandleEx, but it's only available
+      # on Vista+. If you're reading this in 2017 or later, feel free to
+      # refactor this out.
+      #
+      # The '1' here is ObjectNameInformation
+      if NT_SUCCESS(ctypes.windll.ntdll.NtQueryObject(h, 1, buf, len(buf)-2,
+                    None)):
+        out = OBJECT_NAME_INFORMATION.from_buffer(buf)
+        name = out.Name.Buffer.split('\\')[-1]
+        IS_TTY = name.startswith('msys-') and '-pty' in name
+        if IS_TTY:
+          OUT_TYPE = 'bash (msys)'
+    else:
+      # A normal file, or an unknown file type.
+      pass
+  else:
+    # This is non-windows, so we trust isatty.
+    OUT_TYPE = 'pipe or file'
+
+  # Enable native ANSI color codes on Windows 10.
+  if IS_TTY and platform.release() == '10':
+    if enable_native_ansi():
+      should_wrap = False
+
+  colorama.init(wrap=should_wrap)
+
+if __name__ == '__main__':
+  init()
+  print('IS_TTY:', IS_TTY)
+  print('OUT_TYPE:', OUT_TYPE)

data/vendor/depot_tools/split_cl.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python
+# 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.
+
+"""Splits a branch into smaller branches and uploads CLs."""
+
+from __future__ import print_function
+
+import collections
+import os
+import re
+import subprocess2
+import sys
+import tempfile
+
+import gclient_utils
+import git_footers
+import owners
+import owners_finder
+import scm
+
+import git_common as git
+
+
+# If a call to `git cl split` will generate more than this number of CLs, the
+# command will prompt the user to make sure they know what they're doing. Large
+# numbers of CLs generated by `git cl split` have caused infrastructure issues
+# in the past.
+CL_SPLIT_FORCE_LIMIT = 10
+
+
+def ReadFile(file_path):
+  """Returns the content of |file_path|."""
+  with open(file_path) as f:
+    content = f.read()
+  return content
+
+
+def EnsureInGitRepository():
+  """Throws an exception if the current directory is not a git repository."""
+  git.run('rev-parse')
+
+
+def CreateBranchForDirectory(prefix, directory, upstream):
+  """Creates a branch named |prefix| + "_" + |directory| + "_split".
+
+  Return false if the branch already exists. |upstream| is used as upstream for
+  the created branch.
+  """
+  existing_branches = set(git.branches(use_limit = False))
+  branch_name = prefix + '_' + directory + '_split'
+  if branch_name in existing_branches:
+    return False
+  git.run('checkout', '-t', upstream, '-b', branch_name)
+  return True
+
+
+def FormatDescriptionOrComment(txt, directory):
+  """Replaces $directory with |directory| in |txt|."""
+  return txt.replace('$directory', '/' + directory)
+
+
+def AddUploadedByGitClSplitToDescription(description):
+  """Adds a 'This CL was uploaded by git cl split.' line to |description|.
+
+  The line is added before footers, or at the end of |description| if it has no
+  footers.
+  """
+  split_footers = git_footers.split_footers(description)
+  lines = split_footers[0]
+  if not lines[-1] or lines[-1].isspace():
+    lines = lines + ['']
+  lines = lines + ['This CL was uploaded by git cl split.']
+  if split_footers[1]:
+    lines += [''] + split_footers[1]
+  return '\n'.join(lines)
+
+
+def UploadCl(refactor_branch, refactor_branch_upstream, directory, files,
+             description, comment, reviewers, changelist, cmd_upload,
+             cq_dry_run, enable_auto_submit, repository_root):
+  """Uploads a CL with all changes to |files| in |refactor_branch|.
+
+  Args:
+    refactor_branch: Name of the branch that contains the changes to upload.
+    refactor_branch_upstream: Name of the upstream of |refactor_branch|.
+    directory: Path to the directory that contains the OWNERS file for which
+        to upload a CL.
+    files: List of AffectedFile instances to include in the uploaded CL.
+    description: Description of the uploaded CL.
+    comment: Comment to post on the uploaded CL.
+    reviewers: A set of reviewers for the CL.
+    changelist: The Changelist class.
+    cmd_upload: The function associated with the git cl upload command.
+    cq_dry_run: If CL uploads should also do a cq dry run.
+    enable_auto_submit: If CL uploads should also enable auto submit.
+  """
+  # Create a branch.
+  if not CreateBranchForDirectory(
+      refactor_branch, directory, refactor_branch_upstream):
+    print('Skipping ' + directory + ' for which a branch already exists.')
+    return
+
+  # Checkout all changes to files in |files|.
+  deleted_files = []
+  modified_files = []
+  for action, f in files:
+    abspath = os.path.abspath(os.path.join(repository_root, f))
+    if action == 'D':
+      deleted_files.append(abspath)
+    else:
+      modified_files.append(abspath)
+
+  if deleted_files:
+    git.run(*['rm'] + deleted_files)
+  if modified_files:
+    git.run(*['checkout', refactor_branch, '--'] + modified_files)
+
+  # Commit changes. The temporary file is created with delete=False so that it
+  # can be deleted manually after git has read it rather than automatically
+  # when it is closed.
+  with gclient_utils.temporary_file() as tmp_file:
+    gclient_utils.FileWrite(
+        tmp_file, FormatDescriptionOrComment(description, directory))
+    git.run('commit', '-F', tmp_file)
+
+  # Upload a CL.
+  upload_args = ['-f', '-r', ','.join(reviewers)]
+  if cq_dry_run:
+    upload_args.append('--cq-dry-run')
+  if not comment:
+    upload_args.append('--send-mail')
+  if enable_auto_submit:
+    upload_args.append('--enable-auto-submit')
+  print('Uploading CL for ' + directory + '.')
+  cmd_upload(upload_args)
+  if comment:
+    changelist().AddComment(FormatDescriptionOrComment(comment, directory),
+                            publish=True)
+
+
+def GetFilesSplitByOwners(owners_database, files):
+  """Returns a map of files split by OWNERS file.
+
+  Returns:
+    A map where keys are paths to directories containing an OWNERS file and
+    values are lists of files sharing an OWNERS file.
+  """
+  files_split_by_owners = collections.defaultdict(list)
+  for action, path in files:
+    enclosing_dir = owners_database.enclosing_dir_with_owners(path)
+    files_split_by_owners[enclosing_dir].append((action, path))
+  return files_split_by_owners
+
+
+def PrintClInfo(cl_index, num_cls, directory, file_paths, description,
+                reviewers):
+  """Prints info about a CL.
+
+  Args:
+    cl_index: The index of this CL in the list of CLs to upload.
+    num_cls: The total number of CLs that will be uploaded.
+    directory: Path to the directory that contains the OWNERS file for which
+        to upload a CL.
+    file_paths: A list of files in this CL.
+    description: The CL description.
+    reviewers: A set of reviewers for this CL.
+  """
+  description_lines = FormatDescriptionOrComment(description,
+                                                 directory).splitlines()
+  indented_description = '\n'.join(['    ' + l for l in description_lines])
+
+  print('CL {}/{}'.format(cl_index, num_cls))
+  print('Path: {}'.format(directory))
+  print('Reviewers: {}'.format(', '.join(reviewers)))
+  print('\n' + indented_description + '\n')
+  print('\n'.join(file_paths))
+  print()
+
+
+def SplitCl(description_file, comment_file, changelist, cmd_upload, dry_run,
+            cq_dry_run, enable_auto_submit, repository_root):
+  """"Splits a branch into smaller branches and uploads CLs.
+
+  Args:
+    description_file: File containing the description of uploaded CLs.
+    comment_file: File containing the comment of uploaded CLs.
+    changelist: The Changelist class.
+    cmd_upload: The function associated with the git cl upload command.
+    dry_run: Whether this is a dry run (no branches or CLs created).
+    cq_dry_run: If CL uploads should also do a cq dry run.
+    enable_auto_submit: If CL uploads should also enable auto submit.
+
+  Returns:
+    0 in case of success. 1 in case of error.
+  """
+  description = AddUploadedByGitClSplitToDescription(ReadFile(description_file))
+  comment = ReadFile(comment_file) if comment_file else None
+
+  try:
+    EnsureInGitRepository()
+
+    cl = changelist()
+    upstream = cl.GetCommonAncestorWithUpstream()
+    files = [
+        (action.strip(), f)
+        for action, f in scm.GIT.CaptureStatus(repository_root, upstream)
+    ]
+
+    if not files:
+      print('Cannot split an empty CL.')
+      return 1
+
+    author = git.run('config', 'user.email').strip() or None
+    refactor_branch = git.current_branch()
+    assert refactor_branch, "Can't run from detached branch."
+    refactor_branch_upstream = git.upstream(refactor_branch)
+    assert refactor_branch_upstream, \
+        "Branch %s must have an upstream." % refactor_branch
+
+    owners_database = owners.Database(repository_root, open, os.path)
+    owners_database.load_data_needed_for([f for _, f in files])
+
+    files_split_by_owners = GetFilesSplitByOwners(owners_database, files)
+
+    num_cls = len(files_split_by_owners)
+    print('Will split current branch (' + refactor_branch + ') into ' +
+          str(num_cls) + ' CLs.\n')
+    if cq_dry_run and num_cls > CL_SPLIT_FORCE_LIMIT:
+      print(
+        'This will generate "%r" CLs. This many CLs can potentially generate'
+        ' too much load on the build infrastructure. Please email'
+        ' infra-dev@chromium.org to ensure that this won\'t  break anything.'
+        ' The infra team reserves the right to cancel your jobs if they are'
+        ' overloading the CQ.' % num_cls)
+      answer = gclient_utils.AskForData('Proceed? (y/n):')
+      if answer.lower() != 'y':
+        return 0
+
+    for cl_index, (directory, files) in \
+        enumerate(files_split_by_owners.items(), 1):
+      # Use '/' as a path separator in the branch name and the CL description
+      # and comment.
+      directory = directory.replace(os.path.sep, '/')
+      file_paths = [f for _, f in files]
+      reviewers = owners_database.reviewers_for(file_paths, author)
+
+      if dry_run:
+        PrintClInfo(cl_index, num_cls, directory, file_paths, description,
+                    reviewers)
+      else:
+        UploadCl(refactor_branch, refactor_branch_upstream, directory, files,
+                 description, comment, reviewers, changelist, cmd_upload,
+                 cq_dry_run, enable_auto_submit, repository_root)
+
+    # Go back to the original branch.
+    git.run('checkout', refactor_branch)
+
+  except subprocess2.CalledProcessError as cpe:
+    sys.stderr.write(cpe.stderr)
+    return 1
+  return 0

data/vendor/depot_tools/subcommand.py

@@ -0,0 +1,261 @@
+# 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.
+
+"""Manages subcommands in a script.
+
+Each subcommand should look like this:
+  @usage('[pet name]')
+  def CMDpet(parser, args):
+    '''Prints a pet.
+
+    Many people likes pet. This command prints a pet for your pleasure.
+    '''
+    parser.add_option('--color', help='color of your pet')
+    options, args = parser.parse_args(args)
+    if len(args) != 1:
+      parser.error('A pet name is required')
+    pet = args[0]
+    if options.color:
+      print('Nice %s %d' % (options.color, pet))
+    else:
+      print('Nice %s' % pet)
+    return 0
+
+Explanation:
+  - usage decorator alters the 'usage: %prog' line in the command's help.
+  - docstring is used to both short help line and long help line.
+  - parser can be augmented with arguments.
+  - return the exit code.
+  - Every function in the specified module with a name starting with 'CMD' will
+    be a subcommand.
+  - The module's docstring will be used in the default 'help' page.
+  - If a command has no docstring, it will not be listed in the 'help' page.
+    Useful to keep compatibility commands around or aliases.
+  - If a command is an alias to another one, it won't be documented. E.g.:
+      CMDoldname = CMDnewcmd
+    will result in oldname not being documented but supported and redirecting to
+    newcmd. Make it a real function that calls the old function if you want it
+    to be documented.
+  - CMDfoo_bar will be command 'foo-bar'.
+"""
+
+import difflib
+import sys
+import textwrap
+
+
+def usage(more):
+  """Adds a 'usage_more' property to a CMD function."""
+  def hook(fn):
+    fn.usage_more = more
+    return fn
+  return hook
+
+
+def epilog(text):
+  """Adds an 'epilog' property to a CMD function.
+
+  It will be shown in the epilog. Usually useful for examples.
+  """
+  def hook(fn):
+    fn.epilog = text
+    return fn
+  return hook
+
+
+def CMDhelp(parser, args):
+  """Prints list of commands or help for a specific command."""
+  # This is the default help implementation. It can be disabled or overridden if
+  # wanted.
+  if not any(i in ('-h', '--help') for i in args):
+    args = args + ['--help']
+  parser.parse_args(args)
+  # Never gets there.
+  assert False
+
+
+def _get_color_module():
+  """Returns the colorama module if available.
+
+  If so, assumes colors are supported and return the module handle.
+  """
+  return sys.modules.get('colorama') or sys.modules.get('third_party.colorama')
+
+
+def _function_to_name(name):
+  """Returns the name of a CMD function."""
+  return name[3:].replace('_', '-')
+
+
+class CommandDispatcher(object):
+  def __init__(self, module):
+    """module is the name of the main python module where to look for commands.
+
+    The python builtin variable __name__ MUST be used for |module|. If the
+    script is executed in the form 'python script.py', __name__ == '__main__'
+    and sys.modules['script'] doesn't exist. On the other hand if it is unit
+    tested, __main__ will be the unit test's module so it has to reference to
+    itself with 'script'. __name__ always match the right value.
+    """
+    self.module = sys.modules[module]
+
+  def enumerate_commands(self):
+    """Returns a dict of command and their handling function.
+
+    The commands must be in the '__main__' modules. To import a command from a
+    submodule, use:
+      from mysubcommand import CMDfoo
+
+    Automatically adds 'help' if not already defined.
+
+    Normalizes '_' in the commands to '-'.
+
+    A command can be effectively disabled by defining a global variable to None,
+    e.g.:
+      CMDhelp = None
+    """
+    cmds = dict(
+        (_function_to_name(name), getattr(self.module, name))
+        for name in dir(self.module) if name.startswith('CMD'))
+    cmds.setdefault('help', CMDhelp)
+    return cmds
+
+  def find_nearest_command(self, name_asked):
+    """Retrieves the function to handle a command as supplied by the user.
+
+    It automatically tries to guess the _intended command_ by handling typos
+    and/or incomplete names.
+    """
+    commands = self.enumerate_commands()
+    name_to_dash = name_asked.replace('_', '-')
+    if name_to_dash in commands:
+      return commands[name_to_dash]
+
+    # An exact match was not found. Try to be smart and look if there's
+    # something similar.
+    commands_with_prefix = [c for c in commands if c.startswith(name_asked)]
+    if len(commands_with_prefix) == 1:
+      return commands[commands_with_prefix[0]]
+
+    # A #closeenough approximation of levenshtein distance.
+    def close_enough(a, b):
+      return difflib.SequenceMatcher(a=a, b=b).ratio()
+
+    hamming_commands = sorted(
+        ((close_enough(c, name_asked), c) for c in commands),
+        reverse=True)
+    if (hamming_commands[0][0] - hamming_commands[1][0]) < 0.3:
+      # Too ambiguous.
+      return
+
+    if hamming_commands[0][0] < 0.8:
+      # Not similar enough. Don't be a fool and run a random command.
+      return
+
+    return commands[hamming_commands[0][1]]
+
+  def _gen_commands_list(self):
+    """Generates the short list of supported commands."""
+    commands = self.enumerate_commands()
+    docs = sorted(
+        (cmd_name, self._create_command_summary(cmd_name, handler))
+        for cmd_name, handler in commands.items())
+    # Skip commands without a docstring.
+    docs = [i for i in docs if i[1]]
+    # Then calculate maximum length for alignment:
+    length = max(len(c) for c in commands)
+
+    # Look if color is supported.
+    colors = _get_color_module()
+    green = reset = ''
+    if colors:
+      green = colors.Fore.GREEN
+      reset = colors.Fore.RESET
+    return (
+        'Commands are:\n' +
+        ''.join(
+            '  %s%-*s%s %s\n' % (green, length, cmd_name, reset, doc)
+            for cmd_name, doc in docs))
+
+  def _add_command_usage(self, parser, command):
+    """Modifies an OptionParser object with the function's documentation."""
+    cmd_name = _function_to_name(command.__name__)
+    if cmd_name == 'help':
+      cmd_name = '<command>'
+      # Use the module's docstring as the description for the 'help' command if
+      # available.
+      parser.description = (self.module.__doc__ or '').rstrip()
+      if parser.description:
+        parser.description += '\n\n'
+      parser.description += self._gen_commands_list()
+      # Do not touch epilog.
+    else:
+      # Use the command's docstring if available. For commands, unlike module
+      # docstring, realign.
+      lines = (command.__doc__ or '').rstrip().splitlines()
+      if lines[:1]:
+        rest = textwrap.dedent('\n'.join(lines[1:]))
+        parser.description = '\n'.join((lines[0], rest))
+      else:
+        parser.description = lines[0] if lines else ''
+      if parser.description:
+        parser.description += '\n'
+      parser.epilog = getattr(command, 'epilog', None)
+      if parser.epilog:
+        parser.epilog = '\n' + parser.epilog.strip() + '\n'
+
+    more = getattr(command, 'usage_more', '')
+    extra = '' if not more else ' ' + more
+    parser.set_usage('usage: %%prog %s [options]%s' % (cmd_name, extra))
+
+  @staticmethod
+  def _create_command_summary(cmd_name, command):
+    """Creates a oneliner summary from the command's docstring."""
+    if cmd_name != _function_to_name(command.__name__):
+      # Skip aliases. For example using at module level:
+      # CMDfoo = CMDbar
+      return ''
+    doc = command.__doc__ or ''
+    line = doc.split('\n', 1)[0].rstrip('.')
+    if not line:
+      return line
+    return (line[0].lower() + line[1:]).strip()
+
+  def execute(self, parser, args):
+    """Dispatches execution to the right command.
+
+    Fallbacks to 'help' if not disabled.
+    """
+    # Unconditionally disable format_description() and format_epilog().
+    # Technically, a formatter should be used but it's not worth (yet) the
+    # trouble.
+    parser.format_description = lambda _: parser.description or ''
+    parser.format_epilog = lambda _: parser.epilog or ''
+
+    if args:
+      if args[0] in ('-h', '--help') and len(args) > 1:
+        # Reverse the argument order so 'tool --help cmd' is rewritten to
+        # 'tool cmd --help'.
+        args = [args[1], args[0]] + args[2:]
+      command = self.find_nearest_command(args[0])
+      if command:
+        if command.__name__ == 'CMDhelp' and len(args) > 1:
+          # Reverse the argument order so 'tool help cmd' is rewritten to
+          # 'tool cmd --help'. Do it here since we want 'tool help cmd' to work
+          # too.
+          args = [args[1], '--help'] + args[2:]
+          command = self.find_nearest_command(args[0]) or command
+
+        # "fix" the usage and the description now that we know the subcommand.
+        self._add_command_usage(parser, command)
+        return command(parser, args[1:])
+
+    cmdhelp = self.enumerate_commands().get('help')
+    if cmdhelp:
+      # Not a known command. Default to help.
+      self._add_command_usage(parser, cmdhelp)
+      return cmdhelp(parser, args)
+
+    # Nothing can be done.
+    return 2