libv8 7.3.492.27.0 → 8.4.255.0

data/vendor/depot_tools/presubmit_support.py

@@ -6,28 +6,26 @@
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
+from __future__ import print_function
+
 __version__ = '1.8.0'
 
 # TODO(joi) Add caching where appropriate/needed. The API is designed to allow
 # caching (between all different invocations of presubmit scripts for a given
 # change). We should add it as our presubmit scripts start feeling slow.
 
+import argparse
 import ast  # Exposed through the API.
 import contextlib
-import cPickle  # Exposed through the API.
 import cpplint
-import cStringIO  # Exposed through the API.
 import fnmatch  # Exposed through the API.
 import glob
 import inspect
 import itertools
 import json  # Exposed through the API.
 import logging
-import marshal  # Exposed through the API.
 import multiprocessing
-import optparse
 import os  # Somewhat exposed through the API.
-import pickle  # Exposed through the API.
 import random
 import re  # Exposed through the API.
 import signal
@@ -35,11 +33,8 @@ import sys  # Parts exposed through API.
 import tempfile  # Exposed through the API.
 import threading
 import time
-import traceback  # Exposed through the API.
-import types
+import traceback
 import unittest  # Exposed through the API.
-import urllib2  # Exposed through the API.
-import urlparse
 from warnings import warn
 
 # Local imports.
@@ -54,26 +49,43 @@ import presubmit_canned_checks
 import scm
 import subprocess2 as subprocess  # Exposed through the API.
 
+if sys.version_info.major == 2:
+  # TODO(1009814): Expose urllib2 only through urllib_request and urllib_error
+  import urllib2  # Exposed through the API.
+  import urlparse
+  import urllib2 as urllib_request
+  import urllib2 as urllib_error
+else:
+  import urllib.parse as urlparse
+  import urllib.request as urllib_request
+  import urllib.error as urllib_error
 
 # Ask for feedback only once in program lifetime.
 _ASKED_FOR_FEEDBACK = False
 
 
+def time_time():
+  # Use this so that it can be mocked in tests without interfering with python
+  # system machinery.
+  return time.time()
+
+
 class PresubmitFailure(Exception):
   pass
 
 
 class CommandData(object):
-  def __init__(self, name, cmd, kwargs, message):
+  def __init__(self, name, cmd, kwargs, message, python3=False):
     self.name = name
     self.cmd = cmd
     self.stdin = kwargs.get('stdin', None)
-    self.kwargs = kwargs
+    self.kwargs = kwargs.copy()
     self.kwargs['stdout'] = subprocess.PIPE
     self.kwargs['stderr'] = subprocess.STDOUT
     self.kwargs['stdin'] = subprocess.PIPE
     self.message = message
     self.info = None
+    self.python3 = python3
 
 
 # Adapted from
@@ -87,11 +99,8 @@ class CommandData(object):
 # Before a SIGINT is seen, wait(p) will simply call p.wait() and
 # return the result. Once a SIGINT has been seen (in the main process
 # or a subprocess, including the one the current call is waiting for),
-# wait(p) will call p.terminate() and raise ProcessWasInterrupted.
+# wait(p) will call p.terminate().
 class SigintHandler(object):
-  class ProcessWasInterrupted(Exception):
-    pass
-
   sigint_returncodes = {-signal.SIGINT,  # Unix
                         -1073741510,     # Windows
                         }
@@ -99,7 +108,7 @@ class SigintHandler(object):
     self.__lock = threading.Lock()
     self.__processes = set()
     self.__got_sigint = False
-    signal.signal(signal.SIGINT, lambda signal_num, frame: self.interrupt())
+    self.__previous_signal = signal.signal(signal.SIGINT, self.interrupt)
 
   def __on_sigint(self):
     self.__got_sigint = True
@@ -109,9 +118,10 @@ class SigintHandler(object):
       except OSError:
         pass
 
-  def interrupt(self):
+  def interrupt(self, signal_num, frame):
     with self.__lock:
       self.__on_sigint()
+    self.__previous_signal(signal_num, frame)
 
   def got_sigint(self):
     with self.__lock:
@@ -128,15 +138,34 @@ class SigintHandler(object):
       self.__processes.discard(p)
       if code in self.sigint_returncodes:
         self.__on_sigint()
-      if self.__got_sigint:
-        raise self.ProcessWasInterrupted
     return stdout, stderr
 
 sigint_handler = SigintHandler()
 
 
+class Timer(object):
+  def __init__(self, timeout, fn):
+    self.completed = False
+    self._fn = fn
+    self._timer = threading.Timer(timeout, self._onTimer) if timeout else None
+
+  def __enter__(self):
+    if self._timer:
+      self._timer.start()
+    return self
+
+  def __exit__(self, _type, _value, _traceback):
+    if self._timer:
+      self._timer.cancel()
+
+  def _onTimer(self):
+    self._fn()
+    self.completed = True
+
+
 class ThreadPool(object):
-  def __init__(self, pool_size=None):
+  def __init__(self, pool_size=None, timeout=None):
+    self.timeout = timeout
     self._pool_size = pool_size or multiprocessing.cpu_count()
     self._messages = []
     self._messages_lock = threading.Lock()
@@ -144,13 +173,12 @@ class ThreadPool(object):
     self._tests_lock = threading.Lock()
     self._nonparallel_tests = []
 
-  def CallCommand(self, test):
-    """Runs an external program.
-
-    This function converts invocation of .py files and invocations of "python"
-    to vpython invocations.
-    """
-    vpython = 'vpython.bat' if sys.platform == 'win32' else 'vpython'
+  def _GetCommand(self, test):
+    vpython = 'vpython'
+    if test.python3:
+      vpython += '3'
+    if sys.platform == 'win32':
+      vpython += '.bat'
 
     cmd = test.cmd
     if cmd[0] == 'python':
@@ -159,20 +187,51 @@ class ThreadPool(object):
     elif cmd[0].endswith('.py'):
       cmd = [vpython] + cmd
 
+    # On Windows, scripts on the current directory take precedence over PATH, so
+    # that when testing depot_tools on Windows, calling `vpython.bat` will
+    # execute the copy of vpython of the depot_tools under test instead of the
+    # one in the bot.
+    # As a workaround, we run the tests from the parent directory instead.
+    if (cmd[0] == vpython and
+        'cwd' in test.kwargs and
+        os.path.basename(test.kwargs['cwd']) == 'depot_tools'):
+      test.kwargs['cwd'] = os.path.dirname(test.kwargs['cwd'])
+      cmd[1] = os.path.join('depot_tools', cmd[1])
+
+    return cmd
+
+  def _RunWithTimeout(self, cmd, stdin, kwargs):
+    p = subprocess.Popen(cmd, **kwargs)
+    with Timer(self.timeout, p.terminate) as timer:
+      stdout, _ = sigint_handler.wait(p, stdin)
+      if timer.completed:
+        stdout = 'Process timed out after %ss\n%s' % (self.timeout, stdout)
+      return p.returncode, stdout
+
+  def CallCommand(self, test):
+    """Runs an external program.
+
+    This function converts invocation of .py files and invocations of 'python'
+    to vpython invocations.
+    """
+    cmd = self._GetCommand(test)
     try:
-      start = time.time()
-      p = subprocess.Popen(cmd, **test.kwargs)
-      stdout, _ = sigint_handler.wait(p, test.stdin)
-      duration = time.time() - start
-    except OSError as e:
-      duration = time.time() - start
+      start = time_time()
+      returncode, stdout = self._RunWithTimeout(cmd, test.stdin, test.kwargs)
+      duration = time_time() - start
+    except Exception:
+      duration = time_time() - start
       return test.message(
-          '%s exec failure (%4.2fs)\n   %s' % (test.name, duration, e))
-    if p.returncode != 0:
+          '%s\n%s exec failure (%4.2fs)\n%s' % (
+              test.name, ' '.join(cmd), duration, traceback.format_exc()))
+
+    if returncode != 0:
       return test.message(
-          '%s (%4.2fs) failed\n%s' % (test.name, duration, stdout))
+          '%s\n%s (%4.2fs) failed\n%s' % (
+              test.name, ' '.join(cmd), duration, stdout))
+
     if test.info:
-      return test.info('%s (%4.2fs)' % (test.name, duration))
+      return test.info('%s\n%s (%4.2fs)' % (test.name, ' '.join(cmd), duration))
 
   def AddTests(self, tests, parallel=True):
     if parallel:
@@ -233,37 +292,10 @@ def _RightHandSideLinesImpl(affected_files):
       yield (af, line[0], line[1])
 
 
-class PresubmitOutput(object):
-  def __init__(self, input_stream=None, output_stream=None):
-    self.input_stream = input_stream
-    self.output_stream = output_stream
-    self.reviewers = []
-    self.more_cc = []
-    self.written_output = []
-    self.error_count = 0
-
-  def prompt_yes_no(self, prompt_string):
-    self.write(prompt_string)
-    if self.input_stream:
-      response = self.input_stream.readline().strip().lower()
-      if response not in ('y', 'yes'):
-        self.fail()
-    else:
-      self.fail()
-
-  def fail(self):
-    self.error_count += 1
-
-  def should_continue(self):
-    return not self.error_count
-
-  def write(self, s):
-    self.written_output.append(s)
-    if self.output_stream:
-      self.output_stream.write(s)
-
-  def getvalue(self):
-    return ''.join(self.written_output)
+def prompt_should_continue(prompt_string):
+  sys.stdout.write(prompt_string)
+  response = sys.stdin.readline().strip().lower()
+  return response in ('y', 'yes')
 
 
 # Top level object so multiprocessing can pickle
@@ -283,23 +315,29 @@ class _PresubmitResult(object):
     self._items = items or []
     self._long_text = long_text.rstrip()
 
-  def handle(self, output):
-    output.write(self._message)
-    output.write('\n')
+  def handle(self):
+    sys.stdout.write(self._message)
+    sys.stdout.write('\n')
     for index, item in enumerate(self._items):
-      output.write('  ')
+      sys.stdout.write('  ')
       # Write separately in case it's unicode.
-      output.write(str(item))
+      sys.stdout.write(str(item))
       if index < len(self._items) - 1:
-        output.write(' \\')
-      output.write('\n')
+        sys.stdout.write(' \\')
+      sys.stdout.write('\n')
     if self._long_text:
-      output.write('\n***************\n')
+      sys.stdout.write('\n***************\n')
       # Write separately in case it's unicode.
-      output.write(self._long_text)
-      output.write('\n***************\n')
-    if self.fatal:
-      output.fail()
+      sys.stdout.write(self._long_text)
+      sys.stdout.write('\n***************\n')
+
+  def json_format(self):
+    return {
+        'message': self._message,
+        'items': [str(item) for item in self._items],
+        'long_text': self._long_text,
+        'fatal': self.fatal
+    }
 
 
 # Top level object so multiprocessing can pickle
@@ -375,7 +413,7 @@ class GerritAccessor(object):
 
     # Find revision info for the patchset we want.
     if patchset is not None:
-      for rev, rev_info in info['revisions'].iteritems():
+      for rev, rev_info in info['revisions'].items():
         if str(rev_info['_number']) == str(patchset):
           break
       else:
@@ -413,6 +451,9 @@ class GerritAccessor(object):
       reviewers = changeinfo.get('reviewers', {}).get('REVIEWER', [])
     return [r.get('email') for r in reviewers]
 
+  def UpdateDescription(self, description, issue):
+    gerrit_util.SetCommitMessage(self.host, issue, description, notify='NONE')
+
 
 class OutputApi(object):
   """An instance of OutputApi gets passed to presubmit scripts so that they
@@ -450,42 +491,82 @@ class InputApi(object):
   # perspective. Don't modify this list from a presubmit script!
   #
   # Files without an extension aren't included in the list. If you want to
-  # filter them as source files, add r"(^|.*?[\\\/])[^.]+$" to the white list.
-  # Note that ALL CAPS files are black listed in DEFAULT_BLACK_LIST below.
-  DEFAULT_WHITE_LIST = (
+  # filter them as source files, add r'(^|.*?[\\\/])[^.]+$' to the allow list.
+  # Note that ALL CAPS files are skipped in DEFAULT_FILES_TO_SKIP below.
+  DEFAULT_FILES_TO_CHECK = (
       # C++ and friends
-      r".+\.c$", r".+\.cc$", r".+\.cpp$", r".+\.h$", r".+\.m$", r".+\.mm$",
-      r".+\.inl$", r".+\.asm$", r".+\.hxx$", r".+\.hpp$", r".+\.s$", r".+\.S$",
+      r'.+\.c$', r'.+\.cc$', r'.+\.cpp$', r'.+\.h$', r'.+\.m$', r'.+\.mm$',
+      r'.+\.inl$', r'.+\.asm$', r'.+\.hxx$', r'.+\.hpp$', r'.+\.s$', r'.+\.S$',
       # Scripts
-      r".+\.js$", r".+\.py$", r".+\.sh$", r".+\.rb$", r".+\.pl$", r".+\.pm$",
+      r'.+\.js$', r'.+\.py$', r'.+\.sh$', r'.+\.rb$', r'.+\.pl$', r'.+\.pm$',
       # Other
-      r".+\.java$", r".+\.mk$", r".+\.am$", r".+\.css$", r".+\.mojom$",
-      r".+\.fidl$"
+      r'.+\.java$', r'.+\.mk$', r'.+\.am$', r'.+\.css$', r'.+\.mojom$',
+      r'.+\.fidl$'
   )
 
   # Path regexp that should be excluded from being considered containing source
   # files. Don't modify this list from a presubmit script!
-  DEFAULT_BLACK_LIST = (
-      r"testing_support[\\\/]google_appengine[\\\/].*",
-      r".*\bexperimental[\\\/].*",
+  DEFAULT_FILES_TO_SKIP = (
+      r'testing_support[\\\/]google_appengine[\\\/].*',
+      r'.*\bexperimental[\\\/].*',
       # Exclude third_party/.* but NOT third_party/{WebKit,blink}
       # (crbug.com/539768 and crbug.com/836555).
-      r".*\bthird_party[\\\/](?!(WebKit|blink)[\\\/]).*",
+      r'.*\bthird_party[\\\/](?!(WebKit|blink)[\\\/]).*',
       # Output directories (just in case)
-      r".*\bDebug[\\\/].*",
-      r".*\bRelease[\\\/].*",
-      r".*\bxcodebuild[\\\/].*",
-      r".*\bout[\\\/].*",
+      r'.*\bDebug[\\\/].*',
+      r'.*\bRelease[\\\/].*',
+      r'.*\bxcodebuild[\\\/].*',
+      r'.*\bout[\\\/].*',
       # All caps files like README and LICENCE.
-      r".*\b[A-Z0-9_]{2,}$",
+      r'.*\b[A-Z0-9_]{2,}$',
       # SCM (can happen in dual SCM configuration). (Slightly over aggressive)
-      r"(|.*[\\\/])\.git[\\\/].*",
-      r"(|.*[\\\/])\.svn[\\\/].*",
+      r'(|.*[\\\/])\.git[\\\/].*',
+      r'(|.*[\\\/])\.svn[\\\/].*',
       # There is no point in processing a patch file.
-      r".+\.diff$",
-      r".+\.patch$",
+      r'.+\.diff$',
+      r'.+\.patch$',
   )
 
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @property
+  def DEFAULT_WHITE_LIST(self):
+    return self.DEFAULT_FILES_TO_CHECK
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @DEFAULT_WHITE_LIST.setter
+  def DEFAULT_WHITE_LIST(self, value):
+    self.DEFAULT_FILES_TO_CHECK = value
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @property
+  def DEFAULT_ALLOW_LIST(self):
+    return self.DEFAULT_FILES_TO_CHECK
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @DEFAULT_ALLOW_LIST.setter
+  def DEFAULT_ALLOW_LIST(self, value):
+    self.DEFAULT_FILES_TO_CHECK = value
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @property
+  def DEFAULT_BLACK_LIST(self):
+    return self.DEFAULT_FILES_TO_SKIP
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @DEFAULT_BLACK_LIST.setter
+  def DEFAULT_BLACK_LIST(self, value):
+    self.DEFAULT_FILES_TO_SKIP = value
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @property
+  def DEFAULT_BLOCK_LIST(self):
+    return self.DEFAULT_FILES_TO_SKIP
+
+  # TODO(https://crbug.com/1098562): Remove once no longer used
+  @DEFAULT_BLOCK_LIST.setter
+  def DEFAULT_BLOCK_LIST(self, value):
+    self.DEFAULT_FILES_TO_SKIP = value
+
   def __init__(self, change, presubmit_path, is_committing,
       verbose, gerrit_obj, dry_run=None, thread_pool=None, parallel=False):
     """Builds an InputApi object.
@@ -513,9 +594,7 @@ class InputApi(object):
     # so that presubmit scripts don't have to import them.
     self.ast = ast
     self.basename = os.path.basename
-    self.cPickle = cPickle
     self.cpplint = cpplint
-    self.cStringIO = cStringIO
     self.fnmatch = fnmatch
     self.gclient_paths = gclient_paths
     # TODO(yyanagisawa): stop exposing this when python3 become default.
@@ -524,27 +603,27 @@ class InputApi(object):
     self.glob = glob.glob
     self.json = json
     self.logging = logging.getLogger('PRESUBMIT')
-    self.marshal = marshal
     self.os_listdir = os.listdir
     self.os_path = os.path
     self.os_stat = os.stat
     self.os_walk = os.walk
-    self.pickle = pickle
     self.re = re
     self.subprocess = subprocess
+    self.sys = sys
     self.tempfile = tempfile
     self.time = time
-    self.traceback = traceback
     self.unittest = unittest
-    self.urllib2 = urllib2
+    if sys.version_info.major == 2:
+      self.urllib2 = urllib2
+    self.urllib_request = urllib_request
+    self.urllib_error = urllib_error
 
     self.is_windows = sys.platform == 'win32'
 
-    # Set python_executable to 'python'. This is interpreted in CallCommand to
-    # convert to vpython in order to allow scripts in other repos (e.g. src.git)
-    # to automatically pick up that repo's .vpython file, instead of inheriting
-    # the one in depot_tools.
-    self.python_executable = 'python'
+    # Set python_executable to 'vpython' in order to allow scripts in other
+    # repos (e.g. src.git) to automatically pick up that repo's .vpython file,
+    # instead of inheriting the one in depot_tools.
+    self.python_executable = 'vpython'
     self.environ = os.environ
 
     # InputApi.platform is the platform you're currently running on.
@@ -564,13 +643,13 @@ class InputApi(object):
     # TODO(dpranke): figure out a list of all approved owners for a repo
     # in order to be able to handle wildcard OWNERS files?
     self.owners_db = owners.Database(change.RepositoryRoot(),
-                                     fopen=file, os_path=self.os_path)
+                                     fopen=open, os_path=self.os_path)
     self.owners_finder = owners_finder.OwnersFinder
     self.verbose = verbose
     self.Command = CommandData
 
     # Replace <hash_map> and <hash_set> as headers that need to be included
-    # with "base/containers/hash_tables.h" instead.
+    # with 'base/containers/hash_tables.h' instead.
     # Access to a protected member _XX of a client class
     # pylint: disable=protected-access
     self.cpplint._re_pattern_templates = [
@@ -579,6 +658,9 @@ class InputApi(object):
       for (a, b, header) in cpplint._re_pattern_templates
     ]
 
+  def SetTimeout(self, timeout):
+    self.thread_pool.timeout = timeout
+
   def PresubmitLocalPath(self):
     """Returns the local path of the presubmit script currently being run.
 
@@ -592,20 +674,21 @@ class InputApi(object):
   def AffectedFiles(self, include_deletes=True, file_filter=None):
     """Same as input_api.change.AffectedFiles() except only lists files
     (and optionally directories) in the same directory as the current presubmit
-    script, or subdirectories thereof.
+    script, or subdirectories thereof. Note that files are listed using the OS
+    path separator, so backslashes are used as separators on Windows.
     """
-    dir_with_slash = normpath("%s/" % self.PresubmitLocalPath())
+    dir_with_slash = normpath('%s/' % self.PresubmitLocalPath())
     if len(dir_with_slash) == 1:
       dir_with_slash = ''
 
-    return filter(
+    return list(filter(
         lambda x: normpath(x.AbsoluteLocalPath()).startswith(dir_with_slash),
-        self.change.AffectedFiles(include_deletes, file_filter))
+        self.change.AffectedFiles(include_deletes, file_filter)))
 
   def LocalPaths(self):
     """Returns local paths of input_api.AffectedFiles()."""
     paths = [af.LocalPath() for af in self.AffectedFiles()]
-    logging.debug("LocalPaths: %s", paths)
+    logging.debug('LocalPaths: %s', paths)
     return paths
 
   def AbsoluteLocalPaths(self):
@@ -618,36 +701,54 @@ class InputApi(object):
     thereof.
     """
     if include_deletes is not None:
-      warn("AffectedTestableFiles(include_deletes=%s)"
-               " is deprecated and ignored" % str(include_deletes),
+      warn('AffectedTestableFiles(include_deletes=%s)'
+               ' is deprecated and ignored' % str(include_deletes),
            category=DeprecationWarning,
            stacklevel=2)
-    return filter(lambda x: x.IsTestableFile(),
-                  self.AffectedFiles(include_deletes=False, **kwargs))
+    return list(filter(
+        lambda x: x.IsTestableFile(),
+        self.AffectedFiles(include_deletes=False, **kwargs)))
 
   def AffectedTextFiles(self, include_deletes=None):
     """An alias to AffectedTestableFiles for backwards compatibility."""
     return self.AffectedTestableFiles(include_deletes=include_deletes)
 
-  def FilterSourceFile(self, affected_file, white_list=None, black_list=None):
-    """Filters out files that aren't considered "source file".
+  def FilterSourceFile(self, affected_file, files_to_check=None,
+                       files_to_skip=None, allow_list=None, block_list=None,
+                       white_list=None, black_list=None):
+    """Filters out files that aren't considered 'source file'.
 
-    If white_list or black_list is None, InputApi.DEFAULT_WHITE_LIST
-    and InputApi.DEFAULT_BLACK_LIST is used respectively.
+    If files_to_check or files_to_skip is None, InputApi.DEFAULT_FILES_TO_CHECK
+    and InputApi.DEFAULT_FILES_TO_SKIP is used respectively.
 
     The lists will be compiled as regular expression and
     AffectedFile.LocalPath() needs to pass both list.
 
+    Note: if files_to_check or files_to_skip is not set, and
+    white_list/allow_list or black_list/block_list is, then those values are
+    used. This is used for backward compatibility reasons.
+
     Note: Copy-paste this function to suit your needs or use a lambda function.
     """
+    # TODO(https://crbug.com/1098560): Add warnings before removing bc.
+    if files_to_check is None:
+      files_to_check = allow_list or white_list
+    if files_to_skip is None:
+      files_to_skip = block_list or black_list
+
+    if files_to_check is None:
+      files_to_check = self.DEFAULT_FILES_TO_CHECK
+    if files_to_skip is None:
+      files_to_skip = self.DEFAULT_FILES_TO_SKIP
+
     def Find(affected_file, items):
       local_path = affected_file.LocalPath()
       for item in items:
         if self.re.match(item, local_path):
           return True
       return False
-    return (Find(affected_file, white_list or self.DEFAULT_WHITE_LIST) and
-            not Find(affected_file, black_list or self.DEFAULT_BLACK_LIST))
+    return (Find(affected_file, files_to_check) and
+            not Find(affected_file, files_to_skip))
 
   def AffectedSourceFiles(self, source_file):
     """Filter the list of AffectedTestableFiles by the function source_file.
@@ -656,10 +757,10 @@ class InputApi(object):
     """
     if not source_file:
       source_file = self.FilterSourceFile
-    return filter(source_file, self.AffectedTestableFiles())
+    return list(filter(source_file, self.AffectedTestableFiles()))
 
   def RightHandSideLines(self, source_file_filter=None):
-    """An iterator over all text lines in "new" version of changed files.
+    """An iterator over all text lines in 'new' version of changed files.
 
     Only lists lines from new or modified text files in the change that are
     contained by the directory of the currently executing presubmit script.
@@ -729,11 +830,8 @@ class InputApi(object):
     return 'TBR' in self.change.tags or self.change.TBRsFromDescription()
 
   def RunTests(self, tests_mix, parallel=True):
-    # RunTests doesn't actually run tests. It adds them to a ThreadPool that
-    # will run all tests once all PRESUBMIT files are processed.
     tests = []
     msgs = []
-    parallel = parallel and self.parallel
     for t in tests_mix:
       if isinstance(t, OutputApi.PresubmitResult) and t:
         msgs.append(t)
@@ -745,7 +843,11 @@ class InputApi(object):
         if not t.kwargs.get('cwd'):
           t.kwargs['cwd'] = self.PresubmitLocalPath()
     self.thread_pool.AddTests(tests, parallel)
-    if not parallel:
+    # When self.parallel is True (i.e. --parallel is passed as an option)
+    # RunTests doesn't actually run tests. It adds them to a ThreadPool that
+    # will run all tests once all PRESUBMIT files are processed.
+    # Otherwise, it will run them and return the results.
+    if not self.parallel:
       msgs.extend(self.thread_pool.RunAsync())
     return msgs
 
@@ -859,7 +961,7 @@ class AffectedFile(object):
     """Returns an iterator over the lines in the old version of file.
 
     The old version is the file before any modifications in the user's
-    workspace, i.e. the "left hand side".
+    workspace, i.e. the 'left hand side'.
 
     Contents will be empty if the file is a directory or does not exist.
     Note: The carriage returns (LF or CR) are stripped off.
@@ -870,8 +972,8 @@ class AffectedFile(object):
   def NewContents(self):
     """Returns an iterator over the lines in the new version of file.
 
-    The new version is the file in the user's workspace, i.e. the "right hand
-    side".
+    The new version is the file in the user's workspace, i.e. the 'right hand
+    side'.
 
     Contents will be empty if the file is a directory or does not exist.
     Note: The carriage returns (LF or CR) are stripped off.
@@ -951,7 +1053,7 @@ class Change(object):
 
   _AFFECTED_FILES = AffectedFile
 
-  # Matches key/value (or "tag") lines in changelist descriptions.
+  # Matches key/value (or 'tag') lines in changelist descriptions.
   TAG_LINE_RE = re.compile(
       '^[ \t]*(?P<key>[A-Z][A-Z_0-9]*)[ \t]*=[ \t]*(?P<value>.*?)[ \t]*$')
   scm = ''
@@ -990,7 +1092,7 @@ class Change(object):
   def DescriptionText(self):
     """Returns the user-entered changelist description, minus tags.
 
-    Any line in the user-provided description starting with e.g. "FOO="
+    Any line in the user-provided description starting with e.g. 'FOO='
     (whitespace permitted before and around) is considered a tag line.  Such
     lines are stripped out of the description this function returns.
     """
@@ -1007,7 +1109,7 @@ class Change(object):
     self._full_description = description
 
     # From the description text, build up a dictionary of key/value pairs
-    # plus the description minus all key/value or "tag" lines.
+    # plus the description minus all key/value or 'tag' lines.
     description_without_tags = []
     self.tags = {}
     for line in self._full_description.splitlines():
@@ -1021,6 +1123,19 @@ class Change(object):
     self._description_without_tags = (
         '\n'.join(description_without_tags).rstrip())
 
+  def AddDescriptionFooter(self, key, value):
+    """Adds the given footer to the change description.
+
+    Args:
+      key: A string with the key for the git footer. It must conform to
+        the git footers format (i.e. 'List-Of-Tokens') and will be case
+        normalized so that each token is title-cased.
+      value: A string with the value for the git footer.
+    """
+    description = git_footers.add_footer(
+        self.FullDescriptionText(), git_footers.normalize_name(key), value)
+    self.SetDescriptionText(description)
+
   def RepositoryRoot(self):
     """Returns the repository (checkout) root directory for this change,
     as an absolute path.
@@ -1029,35 +1144,44 @@ class Change(object):
 
   def __getattr__(self, attr):
     """Return tags directly as attributes on the object."""
-    if not re.match(r"^[A-Z_]*$", attr):
+    if not re.match(r'^[A-Z_]*$', attr):
       raise AttributeError(self, attr)
     return self.tags.get(attr)
 
+  def GitFootersFromDescription(self):
+    """Return the git footers present in the description.
+
+    Returns:
+      footers: A dict of {footer: [values]} containing a multimap of the footers
+        in the change description.
+    """
+    return git_footers.parse_footers(self.FullDescriptionText())
+
   def BugsFromDescription(self):
     """Returns all bugs referenced in the commit description."""
     tags = [b.strip() for b in self.tags.get('BUG', '').split(',') if b.strip()]
     footers = []
-    unsplit_footers = git_footers.parse_footers(self._full_description).get(
-        'Bug', [])
+    parsed = self.GitFootersFromDescription()
+    unsplit_footers = parsed.get('Bug', []) + parsed.get('Fixed', [])
     for unsplit_footer in unsplit_footers:
       footers += [b.strip() for b in unsplit_footer.split(',')]
     return sorted(set(tags + footers))
 
   def ReviewersFromDescription(self):
     """Returns all reviewers listed in the commit description."""
-    # We don't support a "R:" git-footer for reviewers; that is in metadata.
+    # We don't support a 'R:' git-footer for reviewers; that is in metadata.
     tags = [r.strip() for r in self.tags.get('R', '').split(',') if r.strip()]
     return sorted(set(tags))
 
   def TBRsFromDescription(self):
     """Returns all TBR reviewers listed in the commit description."""
     tags = [r.strip() for r in self.tags.get('TBR', '').split(',') if r.strip()]
-    # TODO(agable): Remove support for 'Tbr:' when TBRs are programmatically
-    # determined by self-CR+1s.
-    footers = git_footers.parse_footers(self._full_description).get('Tbr', [])
+    # TODO(crbug.com/839208): Remove support for 'Tbr:' when TBRs are
+    # programmatically determined by self-CR+1s.
+    footers = self.GitFootersFromDescription().get('Tbr', [])
     return sorted(set(tags + footers))
 
-  # TODO(agable): Delete these once we're sure they're unused.
+  # TODO(crbug.com/753425): Delete these once we're sure they're unused.
   @property
   def BUG(self):
     return ','.join(self.BugsFromDescription())
@@ -1082,21 +1206,22 @@ class Change(object):
     Returns:
       [AffectedFile(path, action), AffectedFile(path, action)]
     """
-    affected = filter(file_filter, self._affected_files)
+    affected = list(filter(file_filter, self._affected_files))
 
     if include_deletes:
       return affected
-    return filter(lambda x: x.Action() != 'D', affected)
+    return list(filter(lambda x: x.Action() != 'D', affected))
 
   def AffectedTestableFiles(self, include_deletes=None, **kwargs):
     """Return a list of the existing text files in a change."""
     if include_deletes is not None:
-      warn("AffectedTeestableFiles(include_deletes=%s)"
-               " is deprecated and ignored" % str(include_deletes),
+      warn('AffectedTeestableFiles(include_deletes=%s)'
+               ' is deprecated and ignored' % str(include_deletes),
            category=DeprecationWarning,
            stacklevel=2)
-    return filter(lambda x: x.IsTestableFile(),
-                  self.AffectedFiles(include_deletes=False, **kwargs))
+    return list(filter(
+        lambda x: x.IsTestableFile(),
+        self.AffectedFiles(include_deletes=False, **kwargs)))
 
   def AffectedTextFiles(self, include_deletes=None):
     """An alias to AffectedTestableFiles for backwards compatibility."""
@@ -1111,7 +1236,7 @@ class Change(object):
     return [af.AbsoluteLocalPath() for af in self.AffectedFiles()]
 
   def RightHandSideLines(self):
-    """An iterator over all text lines in "new" version of changed files.
+    """An iterator over all text lines in 'new' version of changed files.
 
     Lists lines from new or modified text files in the change.
 
@@ -1216,8 +1341,9 @@ class GetTryMastersExecuter(object):
     """
     context = {}
     try:
-      exec script_text in context
-    except Exception, e:
+      exec(compile(script_text, 'PRESUBMIT.py', 'exec', dont_inherit=True),
+           context)
+    except Exception as e:
       raise PresubmitFailure('"%s" had an exception.\n%s'
                              % (presubmit_path, e))
 
@@ -1233,13 +1359,13 @@ class GetTryMastersExecuter(object):
 
 class GetPostUploadExecuter(object):
   @staticmethod
-  def ExecPresubmitScript(script_text, presubmit_path, cl, change):
+  def ExecPresubmitScript(script_text, presubmit_path, gerrit_obj, change):
     """Executes PostUploadHook() from a single presubmit script.
 
     Args:
       script_text: The text of the presubmit script.
       presubmit_path: Project script to run.
-      cl: The Changelist object.
+      gerrit_obj: The GerritAccessor object.
       change: The Change object.
 
     Return:
@@ -1247,8 +1373,9 @@ class GetPostUploadExecuter(object):
     """
     context = {}
     try:
-      exec script_text in context
-    except Exception, e:
+      exec(compile(script_text, 'PRESUBMIT.py', 'exec', dont_inherit=True),
+           context)
+    except Exception as e:
       raise PresubmitFailure('"%s" had an exception.\n%s'
                              % (presubmit_path, e))
 
@@ -1259,16 +1386,16 @@ class GetPostUploadExecuter(object):
     if not len(inspect.getargspec(post_upload_hook)[0]) == 3:
       raise PresubmitFailure(
           'Expected function "PostUploadHook" to take three arguments.')
-    return post_upload_hook(cl, change, OutputApi(False))
+    return post_upload_hook(gerrit_obj, change, OutputApi(False))
 
 
 def _MergeMasters(masters1, masters2):
   """Merges two master maps. Merges also the tests of each builder."""
   result = {}
-  for (master, builders) in itertools.chain(masters1.iteritems(),
-                                            masters2.iteritems()):
+  for (master, builders) in itertools.chain(masters1.items(),
+                                            masters2.items()):
     new_builders = result.setdefault(master, {})
-    for (builder, tests) in builders.iteritems():
+    for (builder, tests) in builders.items():
       new_builders.setdefault(builder, set([])).update(tests)
   return result
 
@@ -1295,27 +1422,27 @@ def DoGetTryMasters(change,
   """
   presubmit_files = ListRelevantPresubmitFiles(changed_files, repository_root)
   if not presubmit_files and verbose:
-    output_stream.write("Warning, no PRESUBMIT.py found.\n")
+    output_stream.write('Warning, no PRESUBMIT.py found.\n')
   results = {}
   executer = GetTryMastersExecuter()
 
   if default_presubmit:
     if verbose:
-      output_stream.write("Running default presubmit script.\n")
+      output_stream.write('Running default presubmit script.\n')
     fake_path = os.path.join(repository_root, 'PRESUBMIT.py')
     results = _MergeMasters(results, executer.ExecPresubmitScript(
         default_presubmit, fake_path, project, change))
   for filename in presubmit_files:
     filename = os.path.abspath(filename)
     if verbose:
-      output_stream.write("Running %s\n" % filename)
+      output_stream.write('Running %s\n' % filename)
     # Accept CRLF presubmit script.
     presubmit_script = gclient_utils.FileRead(filename, 'rU')
     results = _MergeMasters(results, executer.ExecPresubmitScript(
         presubmit_script, filename, project, change))
 
   # Make sets to lists again for later JSON serialization.
-  for builders in results.itervalues():
+  for builders in results.values():
     for builder in builders:
       builders[builder] = list(builders[builder])
 
@@ -1325,23 +1452,19 @@ def DoGetTryMasters(change,
 
 
 def DoPostUploadExecuter(change,
-                         cl,
-                         repository_root,
-                         verbose,
-                         output_stream):
+                         gerrit_obj,
+                         verbose):
   """Execute the post upload hook.
 
   Args:
     change: The Change object.
-    cl: The Changelist object.
-    repository_root: The repository root.
+    gerrit_obj: The GerritAccessor object.
     verbose: Prints debug info.
-    output_stream: A stream to write debug output to.
   """
   presubmit_files = ListRelevantPresubmitFiles(
-      change.LocalPaths(), repository_root)
+      change.LocalPaths(), change.RepositoryRoot())
   if not presubmit_files and verbose:
-    output_stream.write("Warning, no PRESUBMIT.py found.\n")
+    sys.stdout.write('Warning, no PRESUBMIT.py found.\n')
   results = []
   executer = GetPostUploadExecuter()
   # The root presubmit file should be executed after the ones in subdirectories.
@@ -1352,19 +1475,26 @@ def DoPostUploadExecuter(change,
   for filename in presubmit_files:
     filename = os.path.abspath(filename)
     if verbose:
-      output_stream.write("Running %s\n" % filename)
+      sys.stdout.write('Running %s\n' % filename)
     # Accept CRLF presubmit script.
     presubmit_script = gclient_utils.FileRead(filename, 'rU')
     results.extend(executer.ExecPresubmitScript(
-        presubmit_script, filename, cl, change))
-  output_stream.write('\n')
-  if results:
-    output_stream.write('** Post Upload Hook Messages **\n')
+        presubmit_script, filename, gerrit_obj, change))
+
+  if not results:
+    return 0
+
+  sys.stdout.write('\n')
+  sys.stdout.write('** Post Upload Hook Messages **\n')
+
+  exit_code = 0
   for result in results:
-    result.handle(output_stream)
-    output_stream.write('\n')
+    if result.fatal:
+      exit_code = 1
+    result.handle()
+    sys.stdout.write('\n')
 
-  return results
+  return exit_code
 
 
 class PresubmitExecuter(object):
@@ -1412,8 +1542,9 @@ class PresubmitExecuter(object):
     output_api = OutputApi(self.committing)
     context = {}
     try:
-      exec script_text in context
-    except Exception, e:
+      exec(compile(script_text, 'PRESUBMIT.py', 'exec', dont_inherit=True),
+           context)
+    except Exception as e:
       raise PresubmitFailure('"%s" had an exception.\n%s' % (presubmit_path, e))
 
     # These function names must change if we make substantial changes to
@@ -1430,9 +1561,9 @@ class PresubmitExecuter(object):
         logging.debug('Running %s done.', function_name)
         self.more_cc.extend(output_api.more_cc)
       finally:
-        map(os.remove, input_api._named_temporary_files)
-      if not (isinstance(result, types.TupleType) or
-              isinstance(result, types.ListType)):
+        for f in input_api._named_temporary_files:
+          os.remove(f)
+      if not isinstance(result, (tuple, list)):
         raise PresubmitFailure(
           'Presubmit functions must return a tuple or list')
       for item in result:
@@ -1450,13 +1581,12 @@ class PresubmitExecuter(object):
 def DoPresubmitChecks(change,
                       committing,
                       verbose,
-                      output_stream,
-                      input_stream,
                       default_presubmit,
                       may_prompt,
                       gerrit_obj,
                       dry_run=None,
-                      parallel=False):
+                      parallel=False,
+                      json_output=None):
   """Runs all presubmit checks that apply to the files in the change.
 
   This finds all PRESUBMIT.py files in directories enclosing the files in the
@@ -1470,8 +1600,6 @@ def DoPresubmitChecks(change,
     change: The Change object.
     committing: True if 'git cl land' is running, False if 'git cl upload' is.
     verbose: Prints debug info.
-    output_stream: A stream to write output from presubmit tests to.
-    input_stream: A stream to read input from the user.
     default_presubmit: A default presubmit script to execute in any case.
     may_prompt: Enable (y/n) questions on warning or error. If False,
                 any questions are answered with yes by default.
@@ -1480,13 +1608,8 @@ def DoPresubmitChecks(change,
     parallel: if true, all tests specified by input_api.RunTests in all
               PRESUBMIT files will be run in parallel.
 
-  Warning:
-    If may_prompt is true, output_stream SHOULD be sys.stdout and input_stream
-    SHOULD be sys.stdin.
-
   Return:
-    A PresubmitOutput object. Use output.should_continue() to figure out
-    if there were errors or warnings and the caller should abort.
+    1 if presubmit checks failed or 0 otherwise.
   """
   old_environ = os.environ
   try:
@@ -1494,84 +1617,103 @@ def DoPresubmitChecks(change,
     os.environ = os.environ.copy()
     os.environ['PYTHONDONTWRITEBYTECODE'] = '1'
 
-    output = PresubmitOutput(input_stream, output_stream)
     if committing:
-      output.write("Running presubmit commit checks ...\n")
+      sys.stdout.write('Running presubmit commit checks ...\n')
     else:
-      output.write("Running presubmit upload checks ...\n")
-    start_time = time.time()
+      sys.stdout.write('Running presubmit upload checks ...\n')
+    start_time = time_time()
     presubmit_files = ListRelevantPresubmitFiles(
         change.AbsoluteLocalPaths(), change.RepositoryRoot())
     if not presubmit_files and verbose:
-      output.write("Warning, no PRESUBMIT.py found.\n")
+      sys.stdout.write('Warning, no PRESUBMIT.py found.\n')
     results = []
     thread_pool = ThreadPool()
     executer = PresubmitExecuter(change, committing, verbose, gerrit_obj,
                                  dry_run, thread_pool, parallel)
     if default_presubmit:
       if verbose:
-        output.write("Running default presubmit script.\n")
+        sys.stdout.write('Running default presubmit script.\n')
       fake_path = os.path.join(change.RepositoryRoot(), 'PRESUBMIT.py')
       results += executer.ExecPresubmitScript(default_presubmit, fake_path)
     for filename in presubmit_files:
       filename = os.path.abspath(filename)
       if verbose:
-        output.write("Running %s\n" % filename)
+        sys.stdout.write('Running %s\n' % filename)
       # Accept CRLF presubmit script.
       presubmit_script = gclient_utils.FileRead(filename, 'rU')
       results += executer.ExecPresubmitScript(presubmit_script, filename)
 
     results += thread_pool.RunAsync()
 
-    output.more_cc.extend(executer.more_cc)
-    errors = []
-    notifications = []
-    warnings = []
+    messages = {}
+    should_prompt = False
+    presubmits_failed = False
     for result in results:
       if result.fatal:
-        errors.append(result)
+        presubmits_failed = True
+        messages.setdefault('ERRORS', []).append(result)
       elif result.should_prompt:
-        warnings.append(result)
+        should_prompt = True
+        messages.setdefault('Warnings', []).append(result)
       else:
-        notifications.append(result)
-
-    output.write('\n')
-    for name, items in (('Messages', notifications),
-                        ('Warnings', warnings),
-                        ('ERRORS', errors)):
-      if items:
-        output.write('** Presubmit %s **\n' % name)
-        for item in items:
-          item.handle(output)
-          output.write('\n')
-
-    total_time = time.time() - start_time
+        messages.setdefault('Messages', []).append(result)
+
+    sys.stdout.write('\n')
+    for name, items in messages.items():
+      sys.stdout.write('** Presubmit %s **\n' % name)
+      for item in items:
+        item.handle()
+        sys.stdout.write('\n')
+
+    total_time = time_time() - start_time
     if total_time > 1.0:
-      output.write("Presubmit checks took %.1fs to calculate.\n\n" % total_time)
+      sys.stdout.write(
+          'Presubmit checks took %.1fs to calculate.\n\n' % total_time)
 
-    if errors:
-      output.fail()
-    elif warnings:
-      output.write('There were presubmit warnings. ')
+    if not should_prompt and not presubmits_failed:
+      sys.stdout.write('Presubmit checks passed.\n')
+    elif should_prompt:
+      sys.stdout.write('There were presubmit warnings. ')
       if may_prompt:
-        output.prompt_yes_no('Are you sure you wish to continue? (y/N): ')
-    else:
-      output.write('Presubmit checks passed.\n')
+        presubmits_failed = not prompt_should_continue(
+            'Are you sure you wish to continue? (y/N): ')
+
+    if json_output:
+      # Write the presubmit results to json output
+      presubmit_results = {
+        'errors': [
+            error.json_format()
+            for error in messages.get('ERRORS', [])
+        ],
+        'notifications': [
+            notification.json_format()
+            for notification in messages.get('Messages', [])
+        ],
+        'warnings': [
+            warning.json_format()
+            for warning in messages.get('Warnings', [])
+        ],
+        'more_cc': executer.more_cc,
+      }
+
+      gclient_utils.FileWrite(
+          json_output, json.dumps(presubmit_results, sort_keys=True))
 
     global _ASKED_FOR_FEEDBACK
     # Ask for feedback one time out of 5.
     if (len(results) and random.randint(0, 4) == 0 and not _ASKED_FOR_FEEDBACK):
-      output.write(
+      sys.stdout.write(
           'Was the presubmit check useful? If not, run "git cl presubmit -v"\n'
           'to figure out which PRESUBMIT.py was run, then run git blame\n'
           'on the file to figure out who to ask for help.\n')
       _ASKED_FOR_FEEDBACK = True
-    return output
+
+    return 1 if presubmits_failed else 0
   finally:
     os.environ = old_environ
 
 
-def ScanSubDirs(mask, recursive):
+def _scan_sub_dirs(mask, recursive):
   if not recursive:
     return [x for x in glob.glob(mask) if x not in ('.svn', '.git')]
 
@@ -1587,31 +1729,83 @@ def ScanSubDirs(mask, recursive):
   return results
 
 
-def ParseFiles(args, recursive):
+def _parse_files(args, recursive):
   logging.debug('Searching for %s', args)
   files = []
   for arg in args:
-    files.extend([('M', f) for f in ScanSubDirs(arg, recursive)])
+    files.extend([('M', f) for f in _scan_sub_dirs(arg, recursive)])
   return files
 
 
-def load_files(options, args):
-  """Tries to determine the SCM."""
-  files = []
-  if args:
-    files = ParseFiles(args, options.recursive)
+def _parse_change(parser, options):
+  """Process change options.
+
+  Args:
+    parser: The parser used to parse the arguments from command line.
+    options: The arguments parsed from command line.
+  Returns:
+    A GitChange if the change root is a git repository, or a Change otherwise.
+  """
+  if options.files and options.all_files:
+    parser.error('<files> cannot be specified when --all-files is set.')
+
   change_scm = scm.determine_scm(options.root)
-  if change_scm == 'git':
-    change_class = GitChange
-    upstream = options.upstream or None
-    if not files:
-      files = scm.GIT.CaptureStatus([], options.root, upstream)
+  if change_scm != 'git' and not options.files:
+    parser.error('<files> is not optional for unversioned directories.')
+
+  if options.files:
+    change_files = _parse_files(options.files, options.recursive)
+  elif options.all_files:
+    change_files = [('M', f) for f in scm.GIT.GetAllFiles(options.root)]
   else:
-    logging.info('Doesn\'t seem under source control. Got %d files', len(args))
-    if not files:
-      return None, None
-    change_class = Change
-  return change_class, files
+    change_files = scm.GIT.CaptureStatus(
+        options.root, options.upstream or None)
+
+  logging.info('Found %d file(s).', len(change_files))
+
+  change_class = GitChange if change_scm == 'git' else Change
+  return change_class(
+      options.name,
+      options.description,
+      options.root,
+      change_files,
+      options.issue,
+      options.patchset,
+      options.author,
+      upstream=options.upstream)
+
+
+def _parse_gerrit_options(parser, options):
+  """Process gerrit options.
+
+  SIDE EFFECTS: Modifies options.author and options.description from Gerrit if
+  options.gerrit_fetch is set.
+
+  Args:
+    parser: The parser used to parse the arguments from command line.
+    options: The arguments parsed from command line.
+  Returns:
+    A GerritAccessor object if options.gerrit_url is set, or None otherwise.
+  """
+  gerrit_obj = None
+  if options.gerrit_url:
+    gerrit_obj = GerritAccessor(urlparse.urlparse(options.gerrit_url).netloc)
+
+  if not options.gerrit_fetch:
+    return gerrit_obj
+
+  if not options.gerrit_url or not options.issue or not options.patchset:
+    parser.error(
+        '--gerrit_fetch requires --gerrit_url, --issue and --patchset.')
+
+  options.author = gerrit_obj.GetChangeOwner(options.issue)
+  options.description = gerrit_obj.GetChangeDescription(
+      options.issue, options.patchset)
+
+  logging.info('Got author: "%s"', options.author)
+  logging.info('Got description: """\n%s\n"""', options.description)
+
+  return gerrit_obj
 
 
 @contextlib.contextmanager
@@ -1626,97 +1820,97 @@ def canned_check_filter(method_names):
       setattr(presubmit_canned_checks, method_name, lambda *_a, **_kw: [])
     yield
   finally:
-    for name, method in filtered.iteritems():
+    for name, method in filtered.items():
       setattr(presubmit_canned_checks, name, method)
 
 
 def main(argv=None):
-  parser = optparse.OptionParser(usage="%prog [options] <files...>",
-                                 version="%prog " + str(__version__))
-  parser.add_option("-c", "--commit", action="store_true", default=False,
-                   help="Use commit instead of upload checks")
-  parser.add_option("-u", "--upload", action="store_false", dest='commit',
-                   help="Use upload instead of commit checks")
-  parser.add_option("-r", "--recursive", action="store_true",
-                   help="Act recursively")
-  parser.add_option("-v", "--verbose", action="count", default=0,
-                   help="Use 2 times for more debug info")
-  parser.add_option("--name", default='no name')
-  parser.add_option("--author")
-  parser.add_option("--description", default='')
-  parser.add_option("--issue", type='int', default=0)
-  parser.add_option("--patchset", type='int', default=0)
-  parser.add_option("--root", default=os.getcwd(),
-                    help="Search for PRESUBMIT.py up to this directory. "
-                    "If inherit-review-settings-ok is present in this "
-                    "directory, parent directories up to the root file "
-                    "system directories will also be searched.")
-  parser.add_option("--upstream",
-                    help="Git only: the base ref or upstream branch against "
-                    "which the diff should be computed.")
-  parser.add_option("--default_presubmit")
-  parser.add_option("--may_prompt", action='store_true', default=False)
-  parser.add_option("--skip_canned", action='append', default=[],
-                    help="A list of checks to skip which appear in "
-                    "presubmit_canned_checks. Can be provided multiple times "
-                    "to skip multiple canned checks.")
-  parser.add_option("--dry_run", action='store_true',
-                    help=optparse.SUPPRESS_HELP)
-  parser.add_option("--gerrit_url", help=optparse.SUPPRESS_HELP)
-  parser.add_option("--gerrit_fetch", action='store_true',
-                    help=optparse.SUPPRESS_HELP)
-  parser.add_option('--parallel', action='store_true',
-                    help='Run all tests specified by input_api.RunTests in all '
-                         'PRESUBMIT files in parallel.')
-
-  options, args = parser.parse_args(argv)
-
+  parser = argparse.ArgumentParser(usage='%(prog)s [options] <files...>')
+  hooks = parser.add_mutually_exclusive_group()
+  hooks.add_argument('-c', '--commit', action='store_true',
+                     help='Use commit instead of upload checks.')
+  hooks.add_argument('-u', '--upload', action='store_false', dest='commit',
+                     help='Use upload instead of commit checks.')
+  hooks.add_argument('--post_upload', action='store_true',
+                     help='Run post-upload commit hooks.')
+  parser.add_argument('-r', '--recursive', action='store_true',
+                      help='Act recursively.')
+  parser.add_argument('-v', '--verbose', action='count', default=0,
+                      help='Use 2 times for more debug info.')
+  parser.add_argument('--name', default='no name')
+  parser.add_argument('--author')
+  desc = parser.add_mutually_exclusive_group()
+  desc.add_argument('--description', default='', help='The change description.')
+  desc.add_argument('--description_file',
+                    help='File to read change description from.')
+  parser.add_argument('--issue', type=int, default=0)
+  parser.add_argument('--patchset', type=int, default=0)
+  parser.add_argument('--root', default=os.getcwd(),
+                      help='Search for PRESUBMIT.py up to this directory. '
+                      'If inherit-review-settings-ok is present in this '
+                      'directory, parent directories up to the root file '
+                      'system directories will also be searched.')
+  parser.add_argument('--upstream',
+                      help='Git only: the base ref or upstream branch against '
+                      'which the diff should be computed.')
+  parser.add_argument('--default_presubmit')
+  parser.add_argument('--may_prompt', action='store_true', default=False)
+  parser.add_argument('--skip_canned', action='append', default=[],
+                      help='A list of checks to skip which appear in '
+                      'presubmit_canned_checks. Can be provided multiple times '
+                      'to skip multiple canned checks.')
+  parser.add_argument('--dry_run', action='store_true', help=argparse.SUPPRESS)
+  parser.add_argument('--gerrit_url', help=argparse.SUPPRESS)
+  parser.add_argument('--gerrit_fetch', action='store_true',
+                      help=argparse.SUPPRESS)
+  parser.add_argument('--parallel', action='store_true',
+                      help='Run all tests specified by input_api.RunTests in '
+                           'all PRESUBMIT files in parallel.')
+  parser.add_argument('--json_output',
+                      help='Write presubmit errors to json output.')
+  parser.add_argument('--all_files', action='store_true',
+                      help='Mark all files under source control as modified.')
+  parser.add_argument('files', nargs='*',
+                      help='List of files to be marked as modified when '
+                      'executing presubmit or post-upload hooks. fnmatch '
+                      'wildcards can also be used.')
+
+  options = parser.parse_args(argv)
+
+  log_level = logging.ERROR
   if options.verbose >= 2:
-    logging.basicConfig(level=logging.DEBUG)
+    log_level = logging.DEBUG
   elif options.verbose:
-    logging.basicConfig(level=logging.INFO)
-  else:
-    logging.basicConfig(level=logging.ERROR)
-
-  change_class, files = load_files(options, args)
-  if not change_class:
-    parser.error('For unversioned directory, <files> is not optional.')
-  logging.info('Found %d file(s).', len(files))
+    log_level = logging.INFO
+  log_format = ('[%(levelname).1s%(asctime)s %(process)d %(thread)d '
+                '%(filename)s] %(message)s')
+  logging.basicConfig(format=log_format, level=log_level)
 
-  gerrit_obj = None
-  if options.gerrit_url and options.gerrit_fetch:
-    assert options.issue and options.patchset
-    gerrit_obj = GerritAccessor(urlparse.urlparse(options.gerrit_url).netloc)
-    options.author = gerrit_obj.GetChangeOwner(options.issue)
-    options.description = gerrit_obj.GetChangeDescription(options.issue,
-                                                          options.patchset)
-    logging.info('Got author: "%s"', options.author)
-    logging.info('Got description: """\n%s\n"""', options.description)
+  if options.description_file:
+    options.description = gclient_utils.FileRead(options.description_file)
+  gerrit_obj = _parse_gerrit_options(parser, options)
+  change = _parse_change(parser, options)
 
   try:
+    if options.post_upload:
+      return DoPostUploadExecuter(
+          change,
+          gerrit_obj,
+          options.verbose)
     with canned_check_filter(options.skip_canned):
-      results = DoPresubmitChecks(
-          change_class(options.name,
-                       options.description,
-                       options.root,
-                       files,
-                       options.issue,
-                       options.patchset,
-                       options.author,
-                       upstream=options.upstream),
+      return DoPresubmitChecks(
+          change,
           options.commit,
           options.verbose,
-          sys.stdout,
-          sys.stdin,
           options.default_presubmit,
           options.may_prompt,
           gerrit_obj,
           options.dry_run,
-          options.parallel)
-    return not results.should_continue()
-  except PresubmitFailure, e:
-    print >> sys.stderr, e
-    print >> sys.stderr, 'Maybe your depot_tools is out of date?'
+          options.parallel,
+          options.json_output)
+  except PresubmitFailure as e:
+    print(e, file=sys.stderr)
+    print('Maybe your depot_tools is out of date?', file=sys.stderr)
     return 2