libv8 7.8.279.23.0beta1 → 8.4.255.0

data/vendor/depot_tools/README.testing

@@ -1,23 +0,0 @@
-Most of the tests require a local Rietveld server.
-
-To set this up:
-Method 1: Let the presubmit script do the work for you.
-   $ git cl presubmit
-
-Method 2: Manual.
-1) Check out a copy of Rietveld:
-     $ svn checkout http://rietveld.googlecode.com/svn/trunk/ rietveld
-   (Use git-svn if you must, but man is it slow.)
-2) Get the Google App Engine SDK:
-   http://code.google.com/appengine/downloads.html
-3) To run Rietveld you will need Django 1.0, which is not included
-   with the App Engine SDK.  Go to http://www.djangoproject.com/download ,
-   download a Django from the 1.0 series (it's in the sidebar on the right),
-   untar it, then
-     $ export PYTHONPATH=`pwd`/Django-1.0.4
-4) Run Rietveld:
-     $ /path/to/appengine/sdk/dev_appserver.py /path/to/rietveld
-   (If using one of the App Engine launchers, be sure to use port 8080
-   for this project.)
-
-And then, finally, run the tests.

data/vendor/depot_tools/annotated_gclient.py

@@ -1,89 +0,0 @@
-#!/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.
-
-"""Wraps gclient calls with annotated output.
-
-Note that you will have to use -- to stop option parsing for gclient flags.
-
-To run `gclient sync --gclientfile=.gclient` and annotate got_v8_revision:
-  `annotated_gclient.py --revision-mapping='{"src/v8": "got_v8_revision"}' --
-      sync --gclientfile=.gclient`
-"""
-
-import contextlib
-import json
-import optparse
-import os
-import subprocess
-import sys
-import tempfile
-
-
-@contextlib.contextmanager
-def temp_filename(suffix='', prefix='tmp'):
-  output_fd, output_file = tempfile.mkstemp(suffix=suffix, prefix=prefix)
-  os.close(output_fd)
-
-  yield output_file
-
-  try:
-    os.remove(output_file)
-  except OSError as e:
-    print 'Error cleaning up temp file %s: %s' % (output_file, e)
-
-
-def parse_got_revision(filename, revision_mapping):
-  result = {}
-  with open(filename) as f:
-    data = json.load(f)
-
-  for path, info in data['solutions'].iteritems():
-    # gclient json paths always end with a slash
-    path = path.rstrip('/')
-    if path in revision_mapping:
-      propname = revision_mapping[path]
-      result[propname] = info['revision']
-
-  return result
-
-
-def emit_buildprops(got_revisions):
-  for prop, revision in got_revisions.iteritems():
-    print '@@@SET_BUILD_PROPERTY@%s@%s@@@' % (prop, json.dumps(revision))
-
-
-def main():
-  parser = optparse.OptionParser(
-      description=('Runs gclient and annotates the output with any '
-                   'got_revisions.'))
-  parser.add_option('--revision-mapping', default='{}',
-                    help='json dict of directory-to-property mappings.')
-  parser.add_option('--suffix', default='gclient',
-                    help='tempfile suffix')
-  opts, args = parser.parse_args()
-
-  revision_mapping = json.loads(opts.revision_mapping)
-
-  if not args:
-    parser.error('Must provide arguments to gclient.')
-
-  if any(a.startswith('--output-json') for a in args):
-    parser.error('Can\'t call annotated_gclient with --output-json.')
-
-  with temp_filename(opts.suffix) as f:
-    cmd = ['gclient']
-    cmd.extend(args)
-    cmd.extend(['--output-json', f])
-    p = subprocess.Popen(cmd)
-    p.wait()
-
-    if p.returncode == 0:
-      revisions = parse_got_revision(f, revision_mapping)
-      emit_buildprops(revisions)
-    return p.returncode
-
-
-if __name__ == '__main__':
-  sys.exit(main())

data/vendor/depot_tools/appengine_mapper.py

@@ -1,23 +0,0 @@
-# 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.
-
-"""Ensures that all depot_tools talks directly to appengine to avoid SNI."""
-
-import urlparse
-
-
-mapping = {
-  'codereview.chromium.org': 'chromiumcodereview.appspot.com',
-  'crashpad.chromium.org': 'crashpad-home.appspot.com',
-  'bugs.chromium.org': 'monorail-prod.appspot.com',
-  'bugs-staging.chromium.org': 'monorail-staging.appspot.com',
-}
-
-
-def MapUrl(url):
-  parts = list(urlparse.urlsplit(url))
-  new_netloc = mapping.get(parts[1])
-  if new_netloc:
-    parts[1] = new_netloc
-  return urlparse.urlunsplit(parts)

data/vendor/depot_tools/bootstrap/win/manifest.txt

@@ -1,20 +0,0 @@
-# CIPD manifest for Windows tools.
-#
-# We must install anything that we want included on PATH to a different
-# subdirectory than Git, as Git's msys bash strips its root directory
-# from PATH, hence the subdirs.
-#
-# If any paths or package layouts change, updates will be required in
-# "win_tools.bat" and "win_tools.py" templates.
-#
-# "win_tools.bat" has a hard requirement that the Python package contains the
-# string "cpython" and ends with the CIPD tag "version:VERSION". It uses this
-# to extract VERSION.
-
-$VerifiedPlatform windows-386 windows-amd64
-
-@Subdir python
-infra/python/cpython/windows-386 version:2.7.6
-
-@Subdir git
-infra/git/windows-${arch} version:2.21.0.chromium16

data/vendor/depot_tools/bootstrap/win/manifest_bleeding_edge.txt

@@ -1,20 +0,0 @@
-# CIPD manifest for Windows tools.
-#
-# We must install anything that we want included on PATH to a different
-# subdirectory than Git, as Git's msys bash strips its root directory
-# from PATH, hence the subdirs.
-#
-# If any paths or package layouts change, updates will be required in
-# "win_tools.bat" and "win_tools.py" templates.
-#
-# "win_tools.bat" has a hard requirement that the Python package contains the
-# string "cpython" and ends with the CIPD tag "version:VERSION". It uses this
-# to extract VERSION.
-
-$VerifiedPlatform windows-386 windows-amd64
-
-@Subdir python
-infra/python/cpython/${platform} version:2.7.13.chromium7
-
-@Subdir git
-infra/git/windows-${arch} version:2.21.0.chromium16

data/vendor/depot_tools/bootstrap/win/pylint.new.bat

@@ -1,7 +0,0 @@
-@echo off
-:: Copyright (c) 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
-call python "%~dp0pylint.py" %*

data/vendor/depot_tools/buildbucket.py

@@ -1,186 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 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.
-
-"""Tool for interacting with Buildbucket.
-
-Usage:
-  $ depot-tools-auth login https://cr-buildbucket.appspot.com
-  $ buildbucket.py \
-    put \
-    --bucket master.tryserver.chromium.linux \
-    --builder my-builder \
-
-  Puts a build into buildbucket for my-builder on tryserver.chromium.linux.
-"""
-
-import argparse
-import json
-import urlparse
-import os
-import sys
-import time
-
-from third_party import httplib2
-
-import auth
-
-
-BUILDBUCKET_URL = 'https://cr-buildbucket.appspot.com'
-BUILDBUCKET_API_URL = urlparse.urljoin(
-  BUILDBUCKET_URL,
-  '_ah/api/buildbucket/v1/builds',
-)
-
-
-def add_common_arguments(parser):
-  parser.add_argument(
-    '--response-json',
-    help=(
-      'A path to which the response JSON will be written. '
-      'If no valid JSON is received, nothing will be written.'
-    )
-  )
-
-
-def main(argv):
-  parser = argparse.ArgumentParser()
-  parser.add_argument(
-    '-v',
-    '--verbose',
-    action='store_true',
-  )
-  subparsers = parser.add_subparsers(dest='command')
-
-  get_parser = subparsers.add_parser('get')
-  add_common_arguments(get_parser)
-  get_parser.add_argument(
-    '--id',
-    help='The ID of the build to get the status of.',
-    required=True,
-  )
-
-  put_parser = subparsers.add_parser('put')
-  add_common_arguments(put_parser)
-  put_parser.add_argument(
-    '-b',
-    '--bucket',
-    help=(
-      'The bucket to schedule the build on. Typically the master name, e.g.'
-      ' master.tryserver.chromium.linux.'
-    ),
-    required=True,
-  )
-  put_parser.add_argument(
-    '-c',
-    '--changes',
-    help='A flie to load a JSON list of changes dicts from.',
-  )
-  put_parser.add_argument(
-    '-n',
-    '--builder-name',
-    help='The builder to schedule the build on.',
-    required=True,
-  )
-  put_parser.add_argument(
-    '-p',
-    '--properties',
-    help=(
-      'A file to load a JSON dict of properties from. Use "-" to pipe JSON '
-      'from another command.'
-    ),
-  )
-
-  retry_parser = subparsers.add_parser('retry')
-  add_common_arguments(retry_parser)
-  retry_parser.add_argument(
-    '--id',
-    help='The ID of the build to retry.',
-    required=True,
-  )
-
-  args = parser.parse_args()
-
-  body = None
-
-  if args.command == 'get':
-    method = 'GET'
-    url = '%s/%s' % (BUILDBUCKET_API_URL, args.id)
-  elif args.command == 'put':
-    changes = []
-    if args.changes:
-      try:
-        with open(args.changes) as fp:
-          changes.extend(json.load(fp))
-      except (TypeError, ValueError):
-        sys.stderr.write('%s contained invalid JSON list.\n' % args.changes)
-        raise
-
-    properties = {}
-    if args.properties:
-      try:
-        # Allow using pipes to stream properties from another command, e.g.
-        #   echo '{"foo": "bar", "baz": 42}' | buildbucket.py -p -
-        if args.properties == '-':
-          properties.update(json.load(sys.stdin))
-        else:
-          with open(args.properties) as fp:
-            properties.update(json.load(fp))
-      except (TypeError, ValueError):
-        sys.stderr.write('%s contained invalid JSON dict.\n' % args.properties)
-        raise
-
-    body = json.dumps({
-      'bucket': args.bucket,
-      'parameters_json': json.dumps({
-        'builder_name': args.builder_name,
-        'changes': changes,
-        'properties': properties,
-      }),
-    })
-    method = 'PUT'
-    url = BUILDBUCKET_API_URL
-  elif args.command == 'retry':
-    method = 'PUT'
-    url = '%s/%s/retry' % (BUILDBUCKET_API_URL, args.id)
-
-  authenticator = auth.get_authenticator_for_host(
-    BUILDBUCKET_URL,
-    auth.make_auth_config(use_oauth2=True),
-  )
-  http = authenticator.authorize(httplib2.Http())
-  http.force_exception_to_status_code = True
-
-  if args.verbose:
-    print 'Request URL:', url
-    print 'Request method:', method
-    print 'Request body:', body
-
-  response, content = http.request(
-    url,
-    method,
-    body=body,
-    headers={'Content-Type': 'application/json'},
-  )
-
-  if args.verbose:
-    print 'Response:', response
-    print 'Content:', content
-
-  try:
-    content_json = json.loads(content)
-    if args.response_json:
-      with open(args.response_json, 'w') as response_json_file:
-        response_json_file.write(content)
-    build_url = content_json['build']['url']
-  except (ValueError, TypeError, KeyError):
-    pass
-  else:
-    print 'Build: %s' % build_url
-
-  return response.status != 200
-
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv))

data/vendor/depot_tools/checkout.py

@@ -1,431 +0,0 @@
-# coding=utf8
-# 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.
-"""Manages a project checkout.
-
-Includes support only for git.
-"""
-
-import fnmatch
-import logging
-import os
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-
-# The configparser module was renamed in Python 3.
-try:
-  import configparser
-except ImportError:
-  import ConfigParser as configparser
-
-import patch
-import scm
-import subprocess2
-
-
-if sys.platform in ('cygwin', 'win32'):
-  # Disable timeouts on Windows since we can't have shells with timeouts.
-  GLOBAL_TIMEOUT = None
-  FETCH_TIMEOUT = None
-else:
-  # Default timeout of 15 minutes.
-  GLOBAL_TIMEOUT = 15*60
-  # Use a larger timeout for checkout since it can be a genuinely slower
-  # operation.
-  FETCH_TIMEOUT = 30*60
-
-
-def get_code_review_setting(path, key,
-    codereview_settings_file='codereview.settings'):
-  """Parses codereview.settings and return the value for the key if present.
-
-  Don't cache the values in case the file is changed."""
-  # TODO(maruel): Do not duplicate code.
-  settings = {}
-  try:
-    settings_file = open(os.path.join(path, codereview_settings_file), 'r')
-    try:
-      for line in settings_file.readlines():
-        if not line or line.startswith('#'):
-          continue
-        if not ':' in line:
-          # Invalid file.
-          return None
-        k, v = line.split(':', 1)
-        settings[k.strip()] = v.strip()
-    finally:
-      settings_file.close()
-  except IOError:
-    return None
-  return settings.get(key, None)
-
-
-def align_stdout(stdout):
-  """Returns the aligned output of multiple stdouts."""
-  output = ''
-  for item in stdout:
-    item = item.strip()
-    if not item:
-      continue
-    output += ''.join('  %s\n' % line for line in item.splitlines())
-  return output
-
-
-class PatchApplicationFailed(Exception):
-  """Patch failed to be applied."""
-  def __init__(self, errors, verbose):
-    super(PatchApplicationFailed, self).__init__(errors, verbose)
-    self.errors = errors
-    self.verbose = verbose
-
-  def __str__(self):
-    out = []
-    for e in self.errors:
-      p, status = e
-      if p and p.filename:
-        out.append('Failed to apply patch for %s:' % p.filename)
-      if status:
-        out.append(status)
-      if p and self.verbose:
-        out.append('Patch: %s' % p.dump())
-    return '\n'.join(out)
-
-
-class CheckoutBase(object):
-  # Set to None to have verbose output.
-  VOID = subprocess2.VOID
-
-  def __init__(self, root_dir, project_name, post_processors):
-    """
-    Args:
-      post_processor: list of lambda(checkout, patches) to call on each of the
-                      modified files.
-    """
-    super(CheckoutBase, self).__init__()
-    self.root_dir = root_dir
-    self.project_name = project_name
-    if self.project_name is None:
-      self.project_path = self.root_dir
-    else:
-      self.project_path = os.path.join(self.root_dir, self.project_name)
-    # Only used for logging purposes.
-    self._last_seen_revision = None
-    self.post_processors = post_processors
-    assert self.root_dir
-    assert self.project_path
-    assert os.path.isabs(self.project_path)
-
-  def get_settings(self, key):
-    return get_code_review_setting(self.project_path, key)
-
-  def prepare(self, revision):
-    """Checks out a clean copy of the tree and removes any local modification.
-
-    This function shouldn't throw unless the remote repository is inaccessible,
-    there is no free disk space or hard issues like that.
-
-    Args:
-      revision: The revision it should sync to, SCM specific.
-    """
-    raise NotImplementedError()
-
-  def apply_patch(self, patches, post_processors=None, verbose=False):
-    """Applies a patch and returns the list of modified files.
-
-    This function should throw patch.UnsupportedPatchFormat or
-    PatchApplicationFailed when relevant.
-
-    Args:
-      patches: patch.PatchSet object.
-    """
-    raise NotImplementedError()
-
-  def commit(self, commit_message, user):
-    """Commits the patch upstream, while impersonating 'user'."""
-    raise NotImplementedError()
-
-  def revisions(self, rev1, rev2):
-    """Returns the count of revisions from rev1 to rev2, e.g. len(]rev1, rev2]).
-
-    If rev2 is None, it means 'HEAD'.
-
-    Returns None if there is no link between the two.
-    """
-    raise NotImplementedError()
-
-
-class GitCheckout(CheckoutBase):
-  """Manages a git checkout."""
-  def __init__(self, root_dir, project_name, remote_branch, git_url,
-      commit_user, post_processors=None):
-    super(GitCheckout, self).__init__(root_dir, project_name, post_processors)
-    self.git_url = git_url
-    self.commit_user = commit_user
-    self.remote_branch = remote_branch
-    # The working branch where patches will be applied. It will track the
-    # remote branch.
-    self.working_branch = 'working_branch'
-    # There is no reason to not hardcode origin.
-    self.remote = 'origin'
-    # There is no reason to not hardcode master.
-    self.master_branch = 'master'
-
-  def prepare(self, revision):
-    """Resets the git repository in a clean state.
-
-    Checks it out if not present and deletes the working branch.
-    """
-    assert self.remote_branch
-    assert self.git_url
-
-    if not os.path.isdir(self.project_path):
-      # Clone the repo if the directory is not present.
-      logging.info(
-          'Checking out %s in %s', self.project_name, self.project_path)
-      self._check_call_git(
-          ['clone', self.git_url, '-b', self.remote_branch, self.project_path],
-          cwd=None, timeout=FETCH_TIMEOUT)
-    else:
-      # Throw away all uncommitted changes in the existing checkout.
-      self._check_call_git(['checkout', self.remote_branch])
-      self._check_call_git(
-          ['reset', '--hard', '--quiet',
-           '%s/%s' % (self.remote, self.remote_branch)])
-
-    if revision:
-      try:
-        # Look if the commit hash already exist. If so, we can skip a
-        # 'git fetch' call.
-        revision = self._check_output_git(['rev-parse', revision]).rstrip()
-      except subprocess.CalledProcessError:
-        self._check_call_git(
-            ['fetch', self.remote, self.remote_branch, '--quiet'])
-        revision = self._check_output_git(['rev-parse', revision]).rstrip()
-      self._check_call_git(['checkout', '--force', '--quiet', revision])
-    else:
-      branches, active = self._branches()
-      if active != self.master_branch:
-        self._check_call_git(
-            ['checkout', '--force', '--quiet', self.master_branch])
-      self._sync_remote_branch()
-
-      if self.working_branch in branches:
-        self._call_git(['branch', '-D', self.working_branch])
-    return self._get_head_commit_hash()
-
-  def _sync_remote_branch(self):
-    """Syncs the remote branch."""
-    # We do a 'git pull origin master:refs/remotes/origin/master' instead of
-    # 'git pull origin master' because from the manpage for git-pull:
-    #   A parameter <ref> without a colon is equivalent to <ref>: when
-    #   pulling/fetching, so it merges <ref> into the current branch without
-    #   storing the remote branch anywhere locally.
-    remote_tracked_path = 'refs/remotes/%s/%s' % (
-        self.remote, self.remote_branch)
-    self._check_call_git(
-        ['pull', self.remote,
-         '%s:%s' % (self.remote_branch, remote_tracked_path),
-         '--quiet'])
-
-  def _get_head_commit_hash(self):
-    """Gets the current revision (in unicode) from the local branch."""
-    return unicode(self._check_output_git(['rev-parse', 'HEAD']).strip())
-
-  def apply_patch(self, patches, post_processors=None, verbose=False):
-    """Applies a patch on 'working_branch' and switches to it.
-
-    The changes remain staged on the current branch.
-    """
-    post_processors = post_processors or self.post_processors or []
-    # It this throws, the checkout is corrupted. Maybe worth deleting it and
-    # trying again?
-    if self.remote_branch:
-      self._check_call_git(
-          ['checkout', '-b', self.working_branch, '-t', self.remote_branch,
-           '--quiet'])
-
-    errors = []
-    for index, p in enumerate(patches):
-      stdout = []
-      try:
-        filepath = os.path.join(self.project_path, p.filename)
-        if p.is_delete:
-          if (not os.path.exists(filepath) and
-              any(p1.source_filename == p.filename for p1 in patches[0:index])):
-            # The file was already deleted if a prior patch with file rename
-            # was already processed because 'git apply' did it for us.
-            pass
-          else:
-            stdout.append(self._check_output_git(['rm', p.filename]))
-            assert(not os.path.exists(filepath))
-            stdout.append('Deleted.')
-        else:
-          dirname = os.path.dirname(p.filename)
-          full_dir = os.path.join(self.project_path, dirname)
-          if dirname and not os.path.isdir(full_dir):
-            os.makedirs(full_dir)
-            stdout.append('Created missing directory %s.' % dirname)
-          if p.is_binary:
-            content = p.get()
-            with open(filepath, 'wb') as f:
-              f.write(content)
-            stdout.append('Added binary file %d bytes' % len(content))
-            cmd = ['add', p.filename]
-            if verbose:
-              cmd.append('--verbose')
-            stdout.append(self._check_output_git(cmd))
-          else:
-            # No need to do anything special with p.is_new or if not
-            # p.diff_hunks. git apply manages all that already.
-            cmd = ['apply', '--index', '-3', '-p%s' % p.patchlevel]
-            if verbose:
-              cmd.append('--verbose')
-            stdout.append(self._check_output_git(cmd, stdin=p.get(True)))
-        for post in post_processors:
-          post(self, p)
-        if verbose:
-          print p.filename
-          print align_stdout(stdout)
-      except OSError, e:
-        errors.append((p, '%s%s' % (align_stdout(stdout), e)))
-      except subprocess.CalledProcessError, e:
-        errors.append((p,
-            'While running %s;\n%s%s' % (
-              ' '.join(e.cmd),
-              align_stdout(stdout),
-              align_stdout([getattr(e, 'stdout', '')]))))
-    if errors:
-      raise PatchApplicationFailed(errors, verbose)
-    found_files = self._check_output_git(
-        ['-c', 'core.quotePath=false', 'diff', '--ignore-submodules',
-         '--name-only', '--staged']).splitlines(False)
-    if sorted(patches.filenames) != sorted(found_files):
-      extra_files = sorted(set(found_files) - set(patches.filenames))
-      unpatched_files = sorted(set(patches.filenames) - set(found_files))
-      if extra_files:
-        print 'Found extra files: %r' % (extra_files,)
-      if unpatched_files:
-        print 'Found unpatched files: %r' % (unpatched_files,)
-
-
-  def commit(self, commit_message, user):
-    """Commits, updates the commit message and pushes."""
-    # TODO(hinoka): CQ no longer uses this, I think its deprecated.
-    #               Delete this.
-    assert self.commit_user
-    assert isinstance(commit_message, unicode)
-    current_branch = self._check_output_git(
-        ['rev-parse', '--abbrev-ref', 'HEAD']).strip()
-    assert current_branch == self.working_branch
-
-    commit_cmd = ['commit', '-m', commit_message]
-    if user and user != self.commit_user:
-      # We do not have the first or last name of the user, grab the username
-      # from the email and call it the original author's name.
-      # TODO(rmistry): Do not need the below if user is already in
-      #                "Name <email>" format.
-      name = user.split('@')[0]
-      commit_cmd.extend(['--author', '%s <%s>' % (name, user)])
-    self._check_call_git(commit_cmd)
-
-    # Push to the remote repository.
-    self._check_call_git(
-        ['push', 'origin', '%s:%s' % (self.working_branch, self.remote_branch),
-         '--quiet'])
-    # Get the revision after the push.
-    revision = self._get_head_commit_hash()
-    # Switch back to the remote_branch and sync it.
-    self._check_call_git(['checkout', self.remote_branch])
-    self._sync_remote_branch()
-    # Delete the working branch since we are done with it.
-    self._check_call_git(['branch', '-D', self.working_branch])
-
-    return revision
-
-  def _check_call_git(self, args, **kwargs):
-    kwargs.setdefault('cwd', self.project_path)
-    kwargs.setdefault('stdout', self.VOID)
-    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
-    return subprocess2.check_call_out(['git'] + args, **kwargs)
-
-  def _call_git(self, args, **kwargs):
-    """Like check_call but doesn't throw on failure."""
-    kwargs.setdefault('cwd', self.project_path)
-    kwargs.setdefault('stdout', self.VOID)
-    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
-    return subprocess2.call(['git'] + args, **kwargs)
-
-  def _check_output_git(self, args, **kwargs):
-    kwargs.setdefault('cwd', self.project_path)
-    kwargs.setdefault('timeout', GLOBAL_TIMEOUT)
-    return subprocess2.check_output(
-        ['git'] + args, stderr=subprocess2.STDOUT, **kwargs)
-
-  def _branches(self):
-    """Returns the list of branches and the active one."""
-    out = self._check_output_git(['branch']).splitlines(False)
-    branches = [l[2:] for l in out]
-    active = None
-    for l in out:
-      if l.startswith('*'):
-        active = l[2:]
-        break
-    return branches, active
-
-  def revisions(self, rev1, rev2):
-    """Returns the number of actual commits between both hash."""
-    self._fetch_remote()
-
-    rev2 = rev2 or '%s/%s' % (self.remote, self.remote_branch)
-    # Revision range is ]rev1, rev2] and ordering matters.
-    try:
-      out = self._check_output_git(
-          ['log', '--format="%H"' , '%s..%s' % (rev1, rev2)])
-    except subprocess.CalledProcessError:
-      return None
-    return len(out.splitlines())
-
-  def _fetch_remote(self):
-    """Fetches the remote without rebasing."""
-    # git fetch is always verbose even with -q, so redirect its output.
-    self._check_output_git(['fetch', self.remote, self.remote_branch],
-                           timeout=FETCH_TIMEOUT)
-
-
-class ReadOnlyCheckout(object):
-  """Converts a checkout into a read-only one."""
-  def __init__(self, checkout, post_processors=None):
-    super(ReadOnlyCheckout, self).__init__()
-    self.checkout = checkout
-    self.post_processors = (post_processors or []) + (
-        self.checkout.post_processors or [])
-
-  def prepare(self, revision):
-    return self.checkout.prepare(revision)
-
-  def get_settings(self, key):
-    return self.checkout.get_settings(key)
-
-  def apply_patch(self, patches, post_processors=None, verbose=False):
-    return self.checkout.apply_patch(
-        patches, post_processors or self.post_processors, verbose)
-
-  def commit(self, message, user):  # pylint: disable=no-self-use
-    logging.info('Would have committed for %s with message: %s' % (
-        user, message))
-    return 'FAKE'
-
-  def revisions(self, rev1, rev2):
-    return self.checkout.revisions(rev1, rev2)
-
-  @property
-  def project_name(self):
-    return self.checkout.project_name
-
-  @property
-  def project_path(self):
-    return self.checkout.project_path