libv8 6.3.292.48.1 → 6.7.288.46.0

data/vendor/depot_tools/presubmit_support.py

@@ -30,8 +30,10 @@ import os  # Somewhat exposed through the API.
 import pickle  # Exposed through the API.
 import random
 import re  # Exposed through the API.
+import signal
 import sys  # Parts exposed through API.
 import tempfile  # Exposed through the API.
+import threading
 import time
 import traceback  # Exposed through the API.
 import types
@@ -41,7 +43,6 @@ import urlparse
 from warnings import warn
 
 # Local imports.
-import auth
 import fix_encoding
 import gclient_utils
 import git_footers
@@ -49,7 +50,6 @@ import gerrit_util
 import owners
 import owners_finder
 import presubmit_canned_checks
-import rietveld
 import scm
 import subprocess2 as subprocess  # Exposed through the API.
 
@@ -66,11 +66,154 @@ class CommandData(object):
   def __init__(self, name, cmd, kwargs, message):
     self.name = name
     self.cmd = cmd
+    self.stdin = kwargs.get('stdin', None)
     self.kwargs = kwargs
+    self.kwargs['stdout'] = subprocess.PIPE
+    self.kwargs['stderr'] = subprocess.STDOUT
+    self.kwargs['stdin'] = subprocess.PIPE
     self.message = message
     self.info = None
 
 
+# Adapted from
+# https://github.com/google/gtest-parallel/blob/master/gtest_parallel.py#L37
+#
+# An object that catches SIGINT sent to the Python process and notices
+# if processes passed to wait() die by SIGINT (we need to look for
+# both of those cases, because pressing Ctrl+C can result in either
+# the main process or one of the subprocesses getting the signal).
+#
+# 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.
+class SigintHandler(object):
+  class ProcessWasInterrupted(Exception):
+    pass
+
+  sigint_returncodes = {-signal.SIGINT,  # Unix
+                        -1073741510,     # Windows
+                        }
+  def __init__(self):
+    self.__lock = threading.Lock()
+    self.__processes = set()
+    self.__got_sigint = False
+    signal.signal(signal.SIGINT, lambda signal_num, frame: self.interrupt())
+
+  def __on_sigint(self):
+    self.__got_sigint = True
+    while self.__processes:
+      try:
+        self.__processes.pop().terminate()
+      except OSError:
+        pass
+
+  def interrupt(self):
+    with self.__lock:
+      self.__on_sigint()
+
+  def got_sigint(self):
+    with self.__lock:
+      return self.__got_sigint
+
+  def wait(self, p, stdin):
+    with self.__lock:
+      if self.__got_sigint:
+        p.terminate()
+      self.__processes.add(p)
+    stdout, stderr = p.communicate(stdin)
+    code = p.returncode
+    with self.__lock:
+      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 ThreadPool(object):
+  def __init__(self, pool_size=None):
+    self._pool_size = pool_size or multiprocessing.cpu_count()
+    self._messages = []
+    self._messages_lock = threading.Lock()
+    self._tests = []
+    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'
+
+    cmd = test.cmd
+    if cmd[0] == 'python':
+      cmd = list(cmd)
+      cmd[0] = vpython
+    elif cmd[0].endswith('.py'):
+      cmd = [vpython] + cmd
+
+    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
+      return test.message(
+          '%s exec failure (%4.2fs)\n   %s' % (test.name, duration, e))
+    if p.returncode != 0:
+      return test.message(
+          '%s (%4.2fs) failed\n%s' % (test.name, duration, stdout))
+    if test.info:
+      return test.info('%s (%4.2fs)' % (test.name, duration))
+
+  def AddTests(self, tests, parallel=True):
+    if parallel:
+      self._tests.extend(tests)
+    else:
+      self._nonparallel_tests.extend(tests)
+
+  def RunAsync(self):
+    self._messages = []
+
+    def _WorkerFn():
+      while True:
+        test = None
+        with self._tests_lock:
+          if not self._tests:
+            break
+          test = self._tests.pop()
+        result = self.CallCommand(test)
+        if result:
+          with self._messages_lock:
+            self._messages.append(result)
+
+    def _StartDaemon():
+      t = threading.Thread(target=_WorkerFn)
+      t.daemon = True
+      t.start()
+      return t
+
+    while self._nonparallel_tests:
+      test = self._nonparallel_tests.pop()
+      result = self.CallCommand(test)
+      if result:
+        self._messages.append(result)
+
+    if self._tests:
+      threads = [_StartDaemon() for _ in range(self._pool_size)]
+      for worker in threads:
+        worker.join()
+
+    return self._messages
+
+
 def normpath(path):
   '''Version of os.path.normpath that also changes backward slashes to
   forward slashes when not running on Windows.
@@ -137,8 +280,6 @@ class _PresubmitResult(object):
     """
     self._message = message
     self._items = items or []
-    if items:
-      self._items = items
     self._long_text = long_text.rstrip()
 
   def handle(self, output):
@@ -245,6 +386,14 @@ class GerritAccessor(object):
 
     return rev_info['commit']['message']
 
+  def GetDestRef(self, issue):
+    ref = self.GetChangeInfo(issue)['branch']
+    if not ref.startswith('refs/'):
+      # NOTE: it is possible to create 'refs/x' branch,
+      # aka 'refs/heads/refs/x'. However, this is ill-advised.
+      ref = 'refs/heads/%s' % ref
+    return ref
+
   def GetChangeOwner(self, issue):
     return self.GetChangeInfo(issue)['owner']['email']
 
@@ -303,36 +452,20 @@ class OutputApi(object):
         CQ_INCLUDE_TRYBOTS was updated.
     """
     description = cl.GetDescription(force=True)
-    include_re = re.compile(r'^CQ_INCLUDE_TRYBOTS=(.*)$', re.M | re.I)
-
+    trybot_footers = git_footers.parse_footers(description).get(
+        git_footers.normalize_name('Cq-Include-Trybots'), [])
     prior_bots = []
-    if cl.IsGerrit():
-      trybot_footers = git_footers.parse_footers(description).get(
-          git_footers.normalize_name('Cq-Include-Trybots'), [])
-      for f in trybot_footers:
-        prior_bots += [b.strip() for b in f.split(';') if b.strip()]
-    else:
-      trybot_tags = include_re.finditer(description)
-      for t in trybot_tags:
-        prior_bots += [b.strip() for b in t.group(1).split(';') if b.strip()]
+    for f in trybot_footers:
+      prior_bots += [b.strip() for b in f.split(';') if b.strip()]
 
     if set(prior_bots) >= set(bots_to_include):
       return []
     all_bots = ';'.join(sorted(set(prior_bots) | set(bots_to_include)))
 
-    if cl.IsGerrit():
-      description = git_footers.remove_footer(
-          description, 'Cq-Include-Trybots')
-      description = git_footers.add_footer(
-          description, 'Cq-Include-Trybots', all_bots,
-          before_keys=['Change-Id'])
-    else:
-      new_include_trybots = 'CQ_INCLUDE_TRYBOTS=%s' % all_bots
-      m = include_re.search(description)
-      if m:
-        description = include_re.sub(new_include_trybots, description)
-      else:
-        description = '%s\n%s\n' % (description, new_include_trybots)
+    description = git_footers.remove_footer(description, 'Cq-Include-Trybots')
+    description = git_footers.add_footer(
+        description, 'Cq-Include-Trybots', all_bots,
+        before_keys=['Change-Id'])
 
     cl.UpdateDescription(description, force=True)
     return [self.PresubmitNotifyResult(message)]
@@ -358,7 +491,8 @@ class InputApi(object):
       # Scripts
       r".+\.js$", r".+\.py$", r".+\.sh$", r".+\.rb$", r".+\.pl$", r".+\.pm$",
       # Other
-      r".+\.java$", r".+\.mk$", r".+\.am$", r".+\.css$"
+      r".+\.java$", r".+\.mk$", r".+\.am$", r".+\.css$", r".+\.mojom$",
+      r".+\.fidl$"
   )
 
   # Path regexp that should be excluded from being considered containing source
@@ -366,8 +500,9 @@ class InputApi(object):
   DEFAULT_BLACK_LIST = (
       r"testing_support[\\\/]google_appengine[\\\/].*",
       r".*\bexperimental[\\\/].*",
-      # Exclude third_party/.* but NOT third_party/WebKit (crbug.com/539768).
-      r".*\bthird_party[\\\/](?!WebKit[\\\/]).*",
+      # Exclude third_party/.* but NOT third_party/{WebKit,blink}
+      # (crbug.com/539768 and crbug.com/836555).
+      r".*\bthird_party[\\\/](?!(WebKit|blink)[\\\/]).*",
       # Output directories (just in case)
       r".*\bDebug[\\\/].*",
       r".*\bRelease[\\\/].*",
@@ -384,28 +519,27 @@ class InputApi(object):
   )
 
   def __init__(self, change, presubmit_path, is_committing,
-      rietveld_obj, verbose, gerrit_obj=None, dry_run=None):
+      verbose, gerrit_obj, dry_run=None, thread_pool=None, parallel=False):
     """Builds an InputApi object.
 
     Args:
       change: A presubmit.Change object.
       presubmit_path: The path to the presubmit script being processed.
       is_committing: True if the change is about to be committed.
-      rietveld_obj: rietveld.Rietveld client object
       gerrit_obj: provides basic Gerrit codereview functionality.
       dry_run: if true, some Checks will be skipped.
+      parallel: if true, all tests reported via input_api.RunTests for all
+                PRESUBMIT files will be run in parallel.
     """
     # Version number of the presubmit_support script.
     self.version = [int(x) for x in __version__.split('.')]
     self.change = change
     self.is_committing = is_committing
-    self.rietveld = rietveld_obj
     self.gerrit = gerrit_obj
     self.dry_run = dry_run
-    # TBD
-    self.host_url = 'http://codereview.chromium.org'
-    if self.rietveld:
-      self.host_url = self.rietveld.url
+
+    self.parallel = parallel
+    self.thread_pool = thread_pool or ThreadPool()
 
     # We expose various modules and functions as attributes of the input_api
     # so that presubmit scripts don't have to import them.
@@ -432,8 +566,13 @@ class InputApi(object):
     self.unittest = unittest
     self.urllib2 = urllib2
 
-    # To easily fork python.
-    self.python_executable = sys.executable
+    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'
     self.environ = os.environ
 
     # InputApi.platform is the platform you're currently running on.
@@ -441,12 +580,6 @@ class InputApi(object):
 
     self.cpu_count = multiprocessing.cpu_count()
 
-    # this is done here because in RunTests, the current working directory has
-    # changed, which causes Pool() to explode fantastically when run on windows
-    # (because it tries to load the __main__ module, which imports lots of
-    # things relative to the current working directory).
-    self._run_tests_pool = multiprocessing.Pool(self.cpu_count)
-
     # The local path of the currently-being-processed presubmit script.
     self._current_presubmit_path = os.path.dirname(presubmit_path)
 
@@ -462,7 +595,6 @@ class InputApi(object):
                                      fopen=file, os_path=self.os_path)
     self.owners_finder = owners_finder.OwnersFinder
     self.verbose = verbose
-    self.is_windows = sys.platform == 'win32'
     self.Command = CommandData
 
     # Replace <hash_map> and <hash_set> as headers that need to be included
@@ -508,7 +640,7 @@ class InputApi(object):
     """Returns absolute local paths of input_api.AffectedFiles()."""
     return [af.AbsoluteLocalPath() for af in self.AffectedFiles()]
 
-  def AffectedTestableFiles(self, include_deletes=None):
+  def AffectedTestableFiles(self, include_deletes=None, **kwargs):
     """Same as input_api.change.AffectedTestableFiles() except only lists files
     in the same directory as the current presubmit script, or subdirectories
     thereof.
@@ -519,7 +651,7 @@ class InputApi(object):
            category=DeprecationWarning,
            stacklevel=2)
     return filter(lambda x: x.IsTestableFile(),
-                  self.AffectedFiles(include_deletes=False))
+                  self.AffectedFiles(include_deletes=False, **kwargs))
 
   def AffectedTextFiles(self, include_deletes=None):
     """An alias to AffectedTestableFiles for backwards compatibility."""
@@ -625,27 +757,24 @@ 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 = []
     for t in tests_mix:
-      if isinstance(t, OutputApi.PresubmitResult):
+      if isinstance(t, OutputApi.PresubmitResult) and t:
         msgs.append(t)
       else:
         assert issubclass(t.message, _PresubmitResult)
         tests.append(t)
         if self.verbose:
           t.info = _PresubmitNotifyResult
-    if len(tests) > 1 and parallel:
-      # async recipe works around multiprocessing bug handling Ctrl-C
-      msgs.extend(self._run_tests_pool.map_async(CallCommand, tests).get(99999))
-    else:
-      msgs.extend(map(CallCommand, tests))
-    return [m for m in msgs if m]
-
-  def ShutdownPool(self):
-    self._run_tests_pool.close()
-    self._run_tests_pool.join()
-    self._run_tests_pool = None
+        if not t.kwargs.get('cwd'):
+          t.kwargs['cwd'] = self.PresubmitLocalPath()
+    self.thread_pool.AddTests(tests, parallel)
+    if not self.parallel:
+      msgs.extend(self.thread_pool.RunAsync())
+    return msgs
 
 
 class _DiffCache(object):
@@ -982,7 +1111,7 @@ class Change(object):
       return affected
     return filter(lambda x: x.Action() != 'D', affected)
 
-  def AffectedTestableFiles(self, include_deletes=None):
+  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)"
@@ -990,7 +1119,7 @@ class Change(object):
            category=DeprecationWarning,
            stacklevel=2)
     return filter(lambda x: x.IsTestableFile(),
-                  self.AffectedFiles(include_deletes=False))
+                  self.AffectedFiles(include_deletes=False, **kwargs))
 
   def AffectedTextFiles(self, include_deletes=None):
     """An alias to AffectedTestableFiles for backwards compatibility."""
@@ -1262,23 +1391,25 @@ def DoPostUploadExecuter(change,
 
 
 class PresubmitExecuter(object):
-  def __init__(self, change, committing, rietveld_obj, verbose,
-               gerrit_obj=None, dry_run=None):
+  def __init__(self, change, committing, verbose,
+               gerrit_obj, dry_run=None, thread_pool=None, parallel=False):
     """
     Args:
       change: The Change object.
       committing: True if 'git cl land' is running, False if 'git cl upload' is.
-      rietveld_obj: rietveld.Rietveld client object.
       gerrit_obj: provides basic Gerrit codereview functionality.
       dry_run: if true, some Checks will be skipped.
+      parallel: if true, all tests reported via input_api.RunTests for all
+                PRESUBMIT files will be run in parallel.
     """
     self.change = change
     self.committing = committing
-    self.rietveld = rietveld_obj
     self.gerrit = gerrit_obj
     self.verbose = verbose
     self.dry_run = dry_run
     self.more_cc = []
+    self.thread_pool = thread_pool
+    self.parallel = parallel
 
   def ExecPresubmitScript(self, script_text, presubmit_path):
     """Executes a single presubmit script.
@@ -1298,8 +1429,9 @@ class PresubmitExecuter(object):
 
     # Load the presubmit script into context.
     input_api = InputApi(self.change, presubmit_path, self.committing,
-                         self.rietveld, self.verbose,
-                         gerrit_obj=self.gerrit, dry_run=self.dry_run)
+                         self.verbose, gerrit_obj=self.gerrit,
+                         dry_run=self.dry_run, thread_pool=self.thread_pool,
+                         parallel=self.parallel)
     output_api = OutputApi(self.committing)
     context = {}
     try:
@@ -1334,8 +1466,6 @@ class PresubmitExecuter(object):
     else:
       result = ()  # no error since the script doesn't care about current event.
 
-    input_api.ShutdownPool()
-
     # Return the process to the original working directory.
     os.chdir(main_path)
     return result
@@ -1347,9 +1477,9 @@ def DoPresubmitChecks(change,
                       input_stream,
                       default_presubmit,
                       may_prompt,
-                      rietveld_obj,
-                      gerrit_obj=None,
-                      dry_run=None):
+                      gerrit_obj,
+                      dry_run=None,
+                      parallel=False):
   """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
@@ -1368,9 +1498,10 @@ def DoPresubmitChecks(change,
     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.
-    rietveld_obj: rietveld.Rietveld object.
     gerrit_obj: provides basic Gerrit codereview functionality.
     dry_run: if true, some Checks will be skipped.
+    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
@@ -1397,8 +1528,9 @@ def DoPresubmitChecks(change,
     if not presubmit_files and verbose:
       output.write("Warning, no PRESUBMIT.py found.\n")
     results = []
-    executer = PresubmitExecuter(change, committing, rietveld_obj, verbose,
-                                 gerrit_obj, dry_run)
+    thread_pool = ThreadPool()
+    executer = PresubmitExecuter(change, committing, verbose,
+                                 gerrit_obj, dry_run, thread_pool)
     if default_presubmit:
       if verbose:
         output.write("Running default presubmit script.\n")
@@ -1412,6 +1544,8 @@ def DoPresubmitChecks(change,
       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 = []
@@ -1503,17 +1637,14 @@ def load_files(options, args):
   return change_class, files
 
 
-class NonexistantCannedCheckFilter(Exception):
-  pass
-
-
 @contextlib.contextmanager
 def canned_check_filter(method_names):
   filtered = {}
   try:
     for method_name in method_names:
       if not hasattr(presubmit_canned_checks, method_name):
-        raise NonexistantCannedCheckFilter(method_name)
+        logging.warn('Skipping unknown "canned" check %s' % method_name)
+        continue
       filtered[method_name] = getattr(presubmit_canned_checks, method_name)
       setattr(presubmit_canned_checks, method_name, lambda *_a, **_kw: [])
     yield
@@ -1522,29 +1653,6 @@ def canned_check_filter(method_names):
       setattr(presubmit_canned_checks, name, method)
 
 
-def CallCommand(cmd_data):
-  """Runs an external program, potentially from a child process created by the
-  multiprocessing module.
-
-  multiprocessing needs a top level function with a single argument.
-  """
-  cmd_data.kwargs['stdout'] = subprocess.PIPE
-  cmd_data.kwargs['stderr'] = subprocess.STDOUT
-  try:
-    start = time.time()
-    (out, _), code = subprocess.communicate(cmd_data.cmd, **cmd_data.kwargs)
-    duration = time.time() - start
-  except OSError as e:
-    duration = time.time() - start
-    return cmd_data.message(
-        '%s exec failure (%4.2fs)\n   %s' % (cmd_data.name, duration, e))
-  if code != 0:
-    return cmd_data.message(
-        '%s (%4.2fs) failed\n%s' % (cmd_data.name, duration, out))
-  if cmd_data.info:
-    return cmd_data.info('%s (%4.2fs)' % (cmd_data.name, duration))
-
-
 def main(argv=None):
   parser = optparse.OptionParser(usage="%prog [options] <files...>",
                                  version="%prog " + str(__version__))
@@ -1580,17 +1688,11 @@ def main(argv=None):
   parser.add_option("--gerrit_url", help=optparse.SUPPRESS_HELP)
   parser.add_option("--gerrit_fetch", action='store_true',
                     help=optparse.SUPPRESS_HELP)
-  parser.add_option("--rietveld_url", help=optparse.SUPPRESS_HELP)
-  parser.add_option("--rietveld_email", help=optparse.SUPPRESS_HELP)
-  parser.add_option("--rietveld_fetch", action='store_true', default=False,
-                    help=optparse.SUPPRESS_HELP)
-  # These are for OAuth2 authentication for bots. See also apply_issue.py
-  parser.add_option("--rietveld_email_file", help=optparse.SUPPRESS_HELP)
-  parser.add_option("--rietveld_private_key_file", 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.')
 
-  auth.add_auth_options(parser)
   options, args = parser.parse_args(argv)
-  auth_config = auth.extract_auth_config_from_options(options)
 
   if options.verbose >= 2:
     logging.basicConfig(level=logging.DEBUG)
@@ -1599,49 +1701,14 @@ def main(argv=None):
   else:
     logging.basicConfig(level=logging.ERROR)
 
-  if (any((options.rietveld_url, options.rietveld_email_file,
-           options.rietveld_fetch, options.rietveld_private_key_file))
-      and any((options.gerrit_url, options.gerrit_fetch))):
-    parser.error('Options for only codereview --rietveld_* or --gerrit_* '
-                 'allowed')
-
-  if options.rietveld_email and options.rietveld_email_file:
-    parser.error("Only one of --rietveld_email or --rietveld_email_file "
-                 "can be passed to this program.")
-  if options.rietveld_email_file:
-    with open(options.rietveld_email_file, "rb") as f:
-      options.rietveld_email = f.read().strip()
-
   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))
 
-  rietveld_obj, gerrit_obj = None, None
-
-  if options.rietveld_url:
-    # The empty password is permitted: '' is not None.
-    if options.rietveld_private_key_file:
-      rietveld_obj = rietveld.JwtOAuth2Rietveld(
-        options.rietveld_url,
-        options.rietveld_email,
-        options.rietveld_private_key_file)
-    else:
-      rietveld_obj = rietveld.CachingRietveld(
-        options.rietveld_url,
-        auth_config,
-        options.rietveld_email)
-    if options.rietveld_fetch:
-      assert options.issue
-      props = rietveld_obj.get_issue_properties(options.issue, False)
-      options.author = props['owner_email']
-      options.description = props['description']
-      logging.info('Got author: "%s"', options.author)
-      logging.info('Got description: """\n%s\n"""', options.description)
-
+  gerrit_obj = None
   if options.gerrit_url and options.gerrit_fetch:
     assert options.issue and options.patchset
-    rietveld_obj = None
     gerrit_obj = GerritAccessor(urlparse.urlparse(options.gerrit_url).netloc)
     options.author = gerrit_obj.GetChangeOwner(options.issue)
     options.description = gerrit_obj.GetChangeDescription(options.issue,
@@ -1666,18 +1733,13 @@ def main(argv=None):
           sys.stdin,
           options.default_presubmit,
           options.may_prompt,
-          rietveld_obj,
           gerrit_obj,
-          options.dry_run)
+          options.dry_run,
+          options.parallel)
     return not results.should_continue()
-  except NonexistantCannedCheckFilter, e:
-    print >> sys.stderr, (
-      'Attempted to skip nonexistent canned presubmit check: %s' % e.message)
-    return 2
   except PresubmitFailure, e:
     print >> sys.stderr, e
     print >> sys.stderr, 'Maybe your depot_tools is out of date?'
-    print >> sys.stderr, 'If all fails, contact maruel@'
     return 2