libv8 8.4.255.0

data/vendor/depot_tools/roll-dep

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Copyright (c) 2009 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")
+
+# Ensure that "depot_tools" is somewhere in PATH so this tool can be used
+# standalone, but allow other PATH manipulations to take priority.
+PATH=$PATH:$base_dir
+
+if [[ $GCLIENT_PY3 = 1 ]]; then
+  # Explicitly run on Python 3
+  PYTHONDONTWRITEBYTECODE=1 exec vpython3 "$base_dir/roll_dep.py" "$@"
+elif [[ $GCLIENT_PY3 = 0 ]]; then
+  # Explicitly run on Python 2
+  PYTHONDONTWRITEBYTECODE=1 exec vpython "$base_dir/roll_dep.py" "$@"
+else
+  # Run on Python 2 for now, allows default to be flipped.
+  PYTHONDONTWRITEBYTECODE=1 exec vpython3 "$base_dir/roll_dep.py" "$@"
+fi

data/vendor/depot_tools/roll-dep.bat

@@ -0,0 +1,21 @@
+@echo off
+:: Copyright (c) 2012 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.
+IF "%GCLIENT_PY3%" == "1" (
+  :: Explicitly run on Python 3
+  call vpython3 "%~dp0\roll_dep.py" %*
+) ELSE IF "%GCLIENT_PY3%" == "0" (
+  :: Explicitly run on Python 2
+  call vpython "%~dp0\roll_dep.py" %*
+) ELSE (
+  :: Run on Python 3, allows default to be flipped.
+  call vpython3 "%~dp0\roll_dep.py" %*
+)

data/vendor/depot_tools/roll_dep.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python
+# Copyright 2015 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.
+
+"""Rolls DEPS controlled dependency.
+
+Works only with git checkout and git dependencies.  Currently this
+script will always roll to the tip of to origin/master.
+"""
+
+from __future__ import print_function
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+
+NEED_SHELL = sys.platform.startswith('win')
+GCLIENT_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), 'gclient.py')
+
+
+# Commit subject that will be considered a roll. In the format generated by the
+# git log used, so it's "<year>-<month>-<day> <author> <subject>"
+_ROLL_SUBJECT = re.compile(
+    # Date
+    r'^\d\d\d\d-\d\d-\d\d '
+    # Author
+    r'[^ ]+ '
+    # Subject
+    r'('
+      # Generated by
+      # https://skia.googlesource.com/buildbot/+/master/autoroll/go/repo_manager/deps_repo_manager.go
+      r'Roll [^ ]+ [a-f0-9]+\.\.[a-f0-9]+ \(\d+ commits\)'
+      r'|'
+      # Generated by
+      # https://chromium.googlesource.com/infra/infra/+/master/recipes/recipe_modules/recipe_autoroller/api.py
+      r'Roll recipe dependencies \(trivial\)\.'
+    r')$')
+
+
+class Error(Exception):
+  pass
+
+
+class AlreadyRolledError(Error):
+  pass
+
+
+def check_output(*args, **kwargs):
+  """subprocess.check_output() passing shell=True on Windows for git."""
+  kwargs.setdefault('shell', NEED_SHELL)
+  return subprocess.check_output(*args, **kwargs).decode('utf-8')
+
+
+def check_call(*args, **kwargs):
+  """subprocess.check_call() passing shell=True on Windows for git."""
+  kwargs.setdefault('shell', NEED_SHELL)
+  subprocess.check_call(*args, **kwargs)
+
+
+def is_pristine(root, merge_base='origin/master'):
+  """Returns True if a git checkout is pristine."""
+  cmd = ['git', 'diff', '--ignore-submodules', merge_base]
+  return not (check_output(cmd, cwd=root).strip() or
+              check_output(cmd + ['--cached'], cwd=root).strip())
+
+
+def get_log_url(upstream_url, head, master):
+  """Returns an URL to read logs via a Web UI if applicable."""
+  if re.match(r'https://[^/]*\.googlesource\.com/', upstream_url):
+    # gitiles
+    return '%s/+log/%s..%s' % (upstream_url, head[:12], master[:12])
+  if upstream_url.startswith('https://github.com/'):
+    upstream_url = upstream_url.rstrip('/')
+    if upstream_url.endswith('.git'):
+      upstream_url = upstream_url[:-len('.git')]
+    return '%s/compare/%s...%s' % (upstream_url, head[:12], master[:12])
+  return None
+
+
+def should_show_log(upstream_url):
+  """Returns True if a short log should be included in the tree."""
+  # Skip logs for very active projects.
+  if upstream_url.endswith('/v8/v8.git'):
+    return False
+  if 'webrtc' in upstream_url:
+    return False
+  return True
+
+
+def gclient(args):
+  """Executes gclient with the given args and returns the stdout."""
+  return check_output([sys.executable, GCLIENT_PATH] + args).strip()
+
+
+def generate_commit_message(
+    full_dir, dependency, head, roll_to, no_log, log_limit):
+  """Creates the commit message for this specific roll."""
+  commit_range = '%s..%s' % (head, roll_to)
+  commit_range_for_header = '%s..%s' % (head[:9], roll_to[:9])
+  upstream_url = check_output(
+      ['git', 'config', 'remote.origin.url'], cwd=full_dir).strip()
+  log_url = get_log_url(upstream_url, head, roll_to)
+  cmd = ['git', 'log', commit_range, '--date=short', '--no-merges']
+  logs = check_output(
+      # Args with '=' are automatically quoted.
+      cmd + ['--format=%ad %ae %s', '--'],
+      cwd=full_dir).rstrip()
+  logs = re.sub(r'(?m)^(\d\d\d\d-\d\d-\d\d [^@]+)@[^ ]+( .*)$', r'\1\2', logs)
+  lines = logs.splitlines()
+  cleaned_lines = [l for l in lines if not _ROLL_SUBJECT.match(l)]
+  logs = '\n'.join(cleaned_lines) + '\n'
+
+  nb_commits = len(lines)
+  rolls = nb_commits - len(cleaned_lines)
+  header = 'Roll %s/ %s (%d commit%s%s)\n\n' % (
+      dependency,
+      commit_range_for_header,
+      nb_commits,
+      's' if nb_commits > 1 else '',
+      ('; %s trivial rolls' % rolls) if rolls else '')
+  log_section = ''
+  if log_url:
+    log_section = log_url + '\n\n'
+  log_section += '$ %s ' % ' '.join(cmd)
+  log_section += '--format=\'%ad %ae %s\'\n'
+  log_section = log_section.replace(commit_range, commit_range_for_header)
+  # It is important that --no-log continues to work, as it is used by
+  # internal -> external rollers. Please do not remove or break it.
+  if not no_log and should_show_log(upstream_url):
+    if len(cleaned_lines) > log_limit:
+      # Keep the first N/2 log entries and last N/2 entries.
+      lines = logs.splitlines(True)
+      lines = lines[:log_limit//2] + ['(...)\n'] + lines[-log_limit//2:]
+      logs = ''.join(lines)
+    log_section += logs
+  return header + log_section
+
+
+def calculate_roll(full_dir, dependency, roll_to):
+  """Calculates the roll for a dependency by processing gclient_dict, and
+  fetching the dependency via git.
+  """
+  head = gclient(['getdep', '-r', dependency])
+  if not head:
+    raise Error('%s is unpinned.' % dependency)
+  check_call(['git', 'fetch', 'origin', '--quiet'], cwd=full_dir)
+  roll_to = check_output(['git', 'rev-parse', roll_to], cwd=full_dir).strip()
+  return head, roll_to
+
+
+def gen_commit_msg(logs, cmdline, reviewers, bug):
+  """Returns the final commit message."""
+  commit_msg = ''
+  if len(logs) > 1:
+    commit_msg = 'Rolling %d dependencies\n\n' % len(logs)
+  commit_msg += '\n\n'.join(logs)
+  commit_msg += '\nCreated with:\n  ' + cmdline + '\n'
+  commit_msg += 'R=%s\n' % ','.join(reviewers) if reviewers else ''
+  commit_msg += '\nBug: %s\n' % bug if bug else ''
+  return commit_msg
+
+
+def finalize(commit_msg, current_dir, rolls):
+  """Commits changes to the DEPS file, then uploads a CL."""
+  print('Commit message:')
+  print('\n'.join('    ' + i for i in commit_msg.splitlines()))
+
+  check_call(['git', 'add', 'DEPS'], cwd=current_dir)
+  check_call(['git', 'commit', '--quiet', '-m', commit_msg], cwd=current_dir)
+
+  # Pull the dependency to the right revision. This is surprising to users
+  # otherwise.
+  for _head, roll_to, full_dir in sorted(rolls.values()):
+    check_call(['git', 'checkout', '--quiet', roll_to], cwd=full_dir)
+
+
+def main():
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument(
+      '--ignore-dirty-tree', action='store_true',
+      help='Roll anyways, even if there is a diff.')
+  parser.add_argument(
+      '-r', '--reviewer',
+      help='To specify multiple reviewers, use comma separated list, e.g. '
+           '-r joe,jane,john. Defaults to @chromium.org')
+  parser.add_argument('-b', '--bug', help='Associate a bug number to the roll')
+  # It is important that --no-log continues to work, as it is used by
+  # internal -> external rollers. Please do not remove or break it.
+  parser.add_argument(
+      '--no-log', action='store_true',
+      help='Do not include the short log in the commit message')
+  parser.add_argument(
+      '--log-limit', type=int, default=100,
+      help='Trim log after N commits (default: %(default)s)')
+  parser.add_argument(
+      '--roll-to', default='origin/master',
+      help='Specify the new commit to roll to (default: %(default)s)')
+  parser.add_argument(
+      '--key', action='append', default=[],
+      help='Regex(es) for dependency in DEPS file')
+  parser.add_argument('dep_path', nargs='+', help='Path(s) to dependency')
+  args = parser.parse_args()
+
+  if len(args.dep_path) > 1:
+    if args.roll_to != 'origin/master':
+      parser.error(
+          'Can\'t use multiple paths to roll simultaneously and --roll-to')
+    if args.key:
+      parser.error(
+          'Can\'t use multiple paths to roll simultaneously and --key')
+  reviewers = None
+  if args.reviewer:
+    reviewers = args.reviewer.split(',')
+    for i, r in enumerate(reviewers):
+      if not '@' in r:
+        reviewers[i] = r + '@chromium.org'
+
+  gclient_root = gclient(['root'])
+  current_dir = os.getcwd()
+  dependencies = sorted(d.replace('\\', '/').rstrip('/') for d in args.dep_path)
+  cmdline = 'roll-dep ' + ' '.join(dependencies) + ''.join(
+      ' --key ' + k for k in args.key)
+  try:
+    if not args.ignore_dirty_tree and not is_pristine(current_dir):
+      raise Error(
+          'Ensure %s is clean first (no non-merged commits).' % current_dir)
+    # First gather all the information without modifying anything, except for a
+    # git fetch.
+    rolls = {}
+    for dependency in dependencies:
+      full_dir = os.path.normpath(os.path.join(gclient_root, dependency))
+      if not os.path.isdir(full_dir):
+        print('Dependency %s not found at %s' % (dependency, full_dir))
+        full_dir = os.path.normpath(os.path.join(current_dir, dependency))
+        print('Will look for relative dependency at %s' % full_dir)
+        if not os.path.isdir(full_dir):
+          raise Error('Directory not found: %s (%s)' % (dependency, full_dir))
+
+      head, roll_to = calculate_roll(full_dir, dependency, args.roll_to)
+      if roll_to == head:
+        if len(dependencies) == 1:
+          raise AlreadyRolledError('No revision to roll!')
+        print('%s: Already at latest commit %s' % (dependency, roll_to))
+      else:
+        print(
+            '%s: Rolling from %s to %s' % (dependency, head[:10], roll_to[:10]))
+        rolls[dependency] = (head, roll_to, full_dir)
+
+    logs = []
+    setdep_args = []
+    for dependency, (head, roll_to, full_dir) in sorted(rolls.items()):
+      log = generate_commit_message(
+          full_dir, dependency, head, roll_to, args.no_log, args.log_limit)
+      logs.append(log)
+      setdep_args.extend(['-r', '{}@{}'.format(dependency, roll_to)])
+
+    gclient(['setdep'] + setdep_args)
+
+    commit_msg = gen_commit_msg(logs, cmdline, reviewers, args.bug)
+    finalize(commit_msg, current_dir, rolls)
+  except Error as e:
+    sys.stderr.write('error: %s\n' % e)
+    return 2 if isinstance(e, AlreadyRolledError) else 1
+  except subprocess.CalledProcessError:
+    return 1
+
+  print('')
+  if not reviewers:
+    print('You forgot to pass -r, make sure to insert a R=foo@example.com line')
+    print('to the commit description before emailing.')
+    print('')
+  print('Run:')
+  print('  git cl upload --send-mail')
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

data/vendor/depot_tools/scm.py

@@ -0,0 +1,415 @@
+# Copyright (c) 2012 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.
+
+"""SCM-specific utility classes."""
+
+import distutils.version
+import glob
+import io
+import os
+import platform
+import re
+import sys
+
+import gclient_utils
+import subprocess2
+
+
+def ValidateEmail(email):
+  return (
+      re.match(r"^[a-zA-Z0-9._%\-+]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$", email)
+      is not None)
+
+
+def GetCasedPath(path):
+  """Elcheapos way to get the real path case on Windows."""
+  if sys.platform.startswith('win') and os.path.exists(path):
+    # Reconstruct the path.
+    path = os.path.abspath(path)
+    paths = path.split('\\')
+    for i in range(len(paths)):
+      if i == 0:
+        # Skip drive letter.
+        continue
+      subpath = '\\'.join(paths[:i+1])
+      prev = len('\\'.join(paths[:i]))
+      # glob.glob will return the cased path for the last item only. This is why
+      # we are calling it in a loop. Extract the data we want and put it back
+      # into the list.
+      paths[i] = glob.glob(subpath + '*')[0][prev+1:len(subpath)]
+    path = '\\'.join(paths)
+  return path
+
+
+def GenFakeDiff(filename):
+  """Generates a fake diff from a file."""
+  file_content = gclient_utils.FileRead(filename, 'rb').splitlines(True)
+  filename = filename.replace(os.sep, '/')
+  nb_lines = len(file_content)
+  # We need to use / since patch on unix will fail otherwise.
+  data = io.StringIO()
+  data.write("Index: %s\n" % filename)
+  data.write('=' * 67 + '\n')
+  # Note: Should we use /dev/null instead?
+  data.write("--- %s\n" % filename)
+  data.write("+++ %s\n" % filename)
+  data.write("@@ -0,0 +1,%d @@\n" % nb_lines)
+  # Prepend '+' to every lines.
+  for line in file_content:
+    data.write('+')
+    data.write(line)
+  result = data.getvalue()
+  data.close()
+  return result
+
+
+def determine_scm(root):
+  """Similar to upload.py's version but much simpler.
+
+  Returns 'git' or None.
+  """
+  if os.path.isdir(os.path.join(root, '.git')):
+    return 'git'
+  else:
+    try:
+      subprocess2.check_call(
+          ['git', 'rev-parse', '--show-cdup'],
+          stdout=subprocess2.VOID,
+          stderr=subprocess2.VOID,
+          cwd=root)
+      return 'git'
+    except (OSError, subprocess2.CalledProcessError):
+      return None
+
+
+def only_int(val):
+  if val.isdigit():
+    return int(val)
+  else:
+    return 0
+
+
+class GIT(object):
+  current_version = None
+
+  @staticmethod
+  def ApplyEnvVars(kwargs):
+    env = kwargs.pop('env', None) or os.environ.copy()
+    # Don't prompt for passwords; just fail quickly and noisily.
+    # By default, git will use an interactive terminal prompt when a username/
+    # password is needed.  That shouldn't happen in the chromium workflow,
+    # and if it does, then gclient may hide the prompt in the midst of a flood
+    # of terminal spew.  The only indication that something has gone wrong
+    # will be when gclient hangs unresponsively.  Instead, we disable the
+    # password prompt and simply allow git to fail noisily.  The error
+    # message produced by git will be copied to gclient's output.
+    env.setdefault('GIT_ASKPASS', 'true')
+    env.setdefault('SSH_ASKPASS', 'true')
+    # 'cat' is a magical git string that disables pagers on all platforms.
+    env.setdefault('GIT_PAGER', 'cat')
+    return env
+
+  @staticmethod
+  def Capture(args, cwd, strip_out=True, **kwargs):
+    env = GIT.ApplyEnvVars(kwargs)
+    output = subprocess2.check_output(
+        ['git'] + args, cwd=cwd, stderr=subprocess2.PIPE, env=env, **kwargs)
+    output = output.decode('utf-8', 'replace')
+    return output.strip() if strip_out else output
+
+  @staticmethod
+  def CaptureStatus(cwd, upstream_branch):
+    """Returns git status.
+
+    Returns an array of (status, file) tuples."""
+    if upstream_branch is None:
+      upstream_branch = GIT.GetUpstreamBranch(cwd)
+      if upstream_branch is None:
+        raise gclient_utils.Error('Cannot determine upstream branch')
+    command = ['-c', 'core.quotePath=false', 'diff',
+               '--name-status', '--no-renames', '-r', '%s...' % upstream_branch]
+    status = GIT.Capture(command, cwd)
+    results = []
+    if status:
+      for statusline in status.splitlines():
+        # 3-way merges can cause the status can be 'MMM' instead of 'M'. This
+        # can happen when the user has 2 local branches and he diffs between
+        # these 2 branches instead diffing to upstream.
+        m = re.match(r'^(\w)+\t(.+)$', statusline)
+        if not m:
+          raise gclient_utils.Error(
+              'status currently unsupported: %s' % statusline)
+        # Only grab the first letter.
+        results.append(('%s      ' % m.group(1)[0], m.group(2)))
+    return results
+
+  @staticmethod
+  def GetConfig(cwd, key, default=None):
+    try:
+      return GIT.Capture(['config', key], cwd=cwd)
+    except subprocess2.CalledProcessError:
+      return default
+
+  @staticmethod
+  def GetBranchConfig(cwd, branch, key, default=None):
+    assert branch, 'A branch must be given'
+    key = 'branch.%s.%s' % (branch, key)
+    return GIT.GetConfig(cwd, key, default)
+
+  @staticmethod
+  def SetConfig(cwd, key, value=None):
+    if value is None:
+      args = ['config', '--unset', key]
+    else:
+      args = ['config', key, value]
+    GIT.Capture(args, cwd=cwd)
+
+  @staticmethod
+  def SetBranchConfig(cwd, branch, key, value=None):
+    assert branch, 'A branch must be given'
+    key = 'branch.%s.%s' % (branch, key)
+    GIT.SetConfig(cwd, key, value)
+
+  @staticmethod
+  def IsWorkTreeDirty(cwd):
+    return GIT.Capture(['status', '-s'], cwd=cwd) != ''
+
+  @staticmethod
+  def GetEmail(cwd):
+    """Retrieves the user email address if known."""
+    return GIT.GetConfig(cwd, 'user.email', '')
+
+  @staticmethod
+  def ShortBranchName(branch):
+    """Converts a name like 'refs/heads/foo' to just 'foo'."""
+    return branch.replace('refs/heads/', '')
+
+  @staticmethod
+  def GetBranchRef(cwd):
+    """Returns the full branch reference, e.g. 'refs/heads/master'."""
+    try:
+      return GIT.Capture(['symbolic-ref', 'HEAD'], cwd=cwd)
+    except subprocess2.CalledProcessError:
+      return None
+
+  @staticmethod
+  def GetBranch(cwd):
+    """Returns the short branch name, e.g. 'master'."""
+    branchref = GIT.GetBranchRef(cwd)
+    if branchref:
+      return GIT.ShortBranchName(branchref)
+    return None
+
+  @staticmethod
+  def GetRemoteBranches(cwd):
+    return GIT.Capture(['branch', '-r'], cwd=cwd).split()
+
+  @staticmethod
+  def FetchUpstreamTuple(cwd, branch=None):
+    """Returns a tuple containing remote and remote ref,
+       e.g. 'origin', 'refs/heads/master'
+    """
+    try:
+      branch = branch or GIT.GetBranch(cwd)
+    except subprocess2.CalledProcessError:
+      pass
+    if branch:
+      upstream_branch = GIT.GetBranchConfig(cwd, branch, 'merge')
+      if upstream_branch:
+        remote = GIT.GetBranchConfig(cwd, branch, 'remote', '.')
+        return remote, upstream_branch
+
+    upstream_branch = GIT.GetConfig(cwd, 'rietveld.upstream-branch')
+    if upstream_branch:
+      remote = GIT.GetConfig(cwd, 'rietveld.upstream-remote', '.')
+      return remote, upstream_branch
+
+    # Else, try to guess the origin remote.
+    if 'origin/master' in GIT.GetRemoteBranches(cwd):
+      # Fall back on origin/master if it exits.
+      return 'origin', 'refs/heads/master'
+
+    return None, None
+
+  @staticmethod
+  def RefToRemoteRef(ref, remote):
+    """Convert a checkout ref to the equivalent remote ref.
+
+    Returns:
+      A tuple of the remote ref's (common prefix, unique suffix), or None if it
+      doesn't appear to refer to a remote ref (e.g. it's a commit hash).
+    """
+    # TODO(mmoss): This is just a brute-force mapping based of the expected git
+    # config. It's a bit better than the even more brute-force replace('heads',
+    # ...), but could still be smarter (like maybe actually using values gleaned
+    # from the git config).
+    m = re.match('^(refs/(remotes/)?)?branch-heads/', ref or '')
+    if m:
+      return ('refs/remotes/branch-heads/', ref.replace(m.group(0), ''))
+
+    m = re.match('^((refs/)?remotes/)?%s/|(refs/)?heads/' % remote, ref or '')
+    if m:
+      return ('refs/remotes/%s/' % remote, ref.replace(m.group(0), ''))
+
+    return None
+
+  @staticmethod
+  def RemoteRefToRef(ref, remote):
+    assert remote, 'A remote must be given'
+    if not ref or not ref.startswith('refs/'):
+      return None
+    if not ref.startswith('refs/remotes/'):
+      return ref
+    if ref.startswith('refs/remotes/branch-heads/'):
+      return 'refs' + ref[len('refs/remotes'):]
+    if ref.startswith('refs/remotes/%s/' % remote):
+      return 'refs/heads' + ref[len('refs/remotes/%s' % remote):]
+    return None
+
+  @staticmethod
+  def GetUpstreamBranch(cwd):
+    """Gets the current branch's upstream branch."""
+    remote, upstream_branch = GIT.FetchUpstreamTuple(cwd)
+    if remote != '.' and upstream_branch:
+      remote_ref = GIT.RefToRemoteRef(upstream_branch, remote)
+      if remote_ref:
+        upstream_branch = ''.join(remote_ref)
+    return upstream_branch
+
+  @staticmethod
+  def IsAncestor(cwd, maybe_ancestor, ref):
+    """Verifies if |maybe_ancestor| is an ancestor of |ref|."""
+    try:
+      GIT.Capture(['merge-base', '--is-ancestor', maybe_ancestor, ref], cwd=cwd)
+      return True
+    except subprocess2.CalledProcessError:
+      return False
+
+  @staticmethod
+  def GetOldContents(cwd, filename, branch=None):
+    if not branch:
+      branch = GIT.GetUpstreamBranch(cwd)
+    if platform.system() == 'Windows':
+      # git show <sha>:<path> wants a posix path.
+      filename = filename.replace('\\', '/')
+    command = ['show', '%s:%s' % (branch, filename)]
+    try:
+      return GIT.Capture(command, cwd=cwd, strip_out=False)
+    except subprocess2.CalledProcessError:
+      return ''
+
+  @staticmethod
+  def GenerateDiff(cwd, branch=None, branch_head='HEAD', full_move=False,
+                   files=None):
+    """Diffs against the upstream branch or optionally another branch.
+
+    full_move means that move or copy operations should completely recreate the
+    files, usually in the prospect to apply the patch for a try job."""
+    if not branch:
+      branch = GIT.GetUpstreamBranch(cwd)
+    command = ['-c', 'core.quotePath=false', 'diff',
+               '-p', '--no-color', '--no-prefix', '--no-ext-diff',
+               branch + "..." + branch_head]
+    if full_move:
+      command.append('--no-renames')
+    else:
+      command.append('-C')
+    # TODO(maruel): --binary support.
+    if files:
+      command.append('--')
+      command.extend(files)
+    diff = GIT.Capture(command, cwd=cwd, strip_out=False).splitlines(True)
+    for i in range(len(diff)):
+      # In the case of added files, replace /dev/null with the path to the
+      # file being added.
+      if diff[i].startswith('--- /dev/null'):
+        diff[i] = '--- %s' % diff[i+1][4:]
+    return ''.join(diff)
+
+  @staticmethod
+  def GetDifferentFiles(cwd, branch=None, branch_head='HEAD'):
+    """Returns the list of modified files between two branches."""
+    if not branch:
+      branch = GIT.GetUpstreamBranch(cwd)
+    command = ['-c', 'core.quotePath=false', 'diff',
+               '--name-only', branch + "..." + branch_head]
+    return GIT.Capture(command, cwd=cwd).splitlines(False)
+
+  @staticmethod
+  def GetAllFiles(cwd):
+    """Returns the list of all files under revision control."""
+    command = ['-c', 'core.quotePath=false', 'ls-files', '--', '.']
+    return GIT.Capture(command, cwd=cwd).splitlines(False)
+
+  @staticmethod
+  def GetPatchName(cwd):
+    """Constructs a name for this patch."""
+    short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd=cwd)
+    return "%s#%s" % (GIT.GetBranch(cwd), short_sha)
+
+  @staticmethod
+  def GetCheckoutRoot(cwd):
+    """Returns the top level directory of a git checkout as an absolute path.
+    """
+    root = GIT.Capture(['rev-parse', '--show-cdup'], cwd=cwd)
+    return os.path.abspath(os.path.join(cwd, root))
+
+  @staticmethod
+  def GetGitDir(cwd):
+    return os.path.abspath(GIT.Capture(['rev-parse', '--git-dir'], cwd=cwd))
+
+  @staticmethod
+  def IsInsideWorkTree(cwd):
+    try:
+      return GIT.Capture(['rev-parse', '--is-inside-work-tree'], cwd=cwd)
+    except (OSError, subprocess2.CalledProcessError):
+      return False
+
+  @staticmethod
+  def IsDirectoryVersioned(cwd, relative_dir):
+    """Checks whether the given |relative_dir| is part of cwd's repo."""
+    return bool(GIT.Capture(['ls-tree', 'HEAD', relative_dir], cwd=cwd))
+
+  @staticmethod
+  def CleanupDir(cwd, relative_dir):
+    """Cleans up untracked file inside |relative_dir|."""
+    return bool(GIT.Capture(['clean', '-df', relative_dir], cwd=cwd))
+
+  @staticmethod
+  def ResolveCommit(cwd, rev):
+    # We do this instead of rev-parse --verify rev^{commit}, since on Windows
+    # git can be either an executable or batch script, each of which requires
+    # escaping the caret (^) a different way.
+    if gclient_utils.IsFullGitSha(rev):
+      # git-rev parse --verify FULL_GIT_SHA always succeeds, even if we don't
+      # have FULL_GIT_SHA locally. Removing the last character forces git to
+      # check if FULL_GIT_SHA refers to an object in the local database.
+      rev = rev[:-1]
+    try:
+      return GIT.Capture(['rev-parse', '--quiet', '--verify', rev], cwd=cwd)
+    except subprocess2.CalledProcessError:
+      return None
+
+  @staticmethod
+  def IsValidRevision(cwd, rev, sha_only=False):
+    """Verifies the revision is a proper git revision.
+
+    sha_only: Fail unless rev is a sha hash.
+    """
+    sha = GIT.ResolveCommit(cwd, rev)
+    if sha is None:
+      return False
+    if sha_only:
+      return sha == rev.lower()
+    return True
+
+  @classmethod
+  def AssertVersion(cls, min_version):
+    """Asserts git's version is at least min_version."""
+    if cls.current_version is None:
+      current_version = cls.Capture(['--version'], '.')
+      matched = re.search(r'git version (.+)', current_version)
+      cls.current_version = distutils.version.LooseVersion(matched.group(1))
+    min_version = distutils.version.LooseVersion(min_version)
+    return (min_version <= cls.current_version, cls.current_version)