Remove Chromium's custom closure runner.

third_party/closure_compiler/compile2.py

 #!/usr/bin/python
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs Closure compiler on JavaScript files to check for errors and produce
 minified output."""
 
 import argparse
 import os
@@ skipping 24 matching lines @@
 
   _MAP_FILE_FORMAT = "%s.map"
 
   _POLYMER_EXTERNS = os.path.join(_CURRENT_DIR, "externs", "polymer-1.0.js")
 
   def __init__(self, verbose=False):
     """
     Args:
       verbose: Whether this class should output diagnostic messages.
     """
-    self._runner_jar = os.path.join(_CURRENT_DIR, "runner", "runner.jar")
+    self._compiler_jar = os.path.join(_CURRENT_DIR, "compiler", "compiler.jar")
     self._target = None
     self._temp_files = []
     self._verbose = verbose
     self._error_filter = error_filter.PromiseErrorFilter()
 
   def _nuke_temp_files(self):
     """Deletes any temp files this class knows about."""
     if not self._temp_files:
       return
 
@@ skipping 125 matching lines @@
       content: A string of the file contens to write to a temporary file.
 
     Return:
       The filepath of the newly created, written, and closed temporary file.
     """
     with tempfile.NamedTemporaryFile(mode="wt", delete=False) as tmp_file:
       self._temp_files.append(tmp_file.name)
       tmp_file.write(contents)
     return tmp_file.name
 
-  def check(self, sources, out_file=None, runner_args=None, closure_args=None,
+  def check(self, sources, out_file=None, closure_args=None,
             custom_sources=True):
     """Closure compile |sources| while checking for errors.
 
     Args:
       sources: Files to check. sources[0] is the typically the target file.
           sources[1:] are externs and dependencies in topological order. Order
           is not guaranteed if custom_sources is True.
       out_file: A file where the compiled output is written to.
-      runner_args: Arguments passed to runner.jar.
       closure_args: Arguments passed directly to the Closure compiler.
       custom_sources: Whether |sources| was customized by the target (e.g. not
           in GYP dependency order).
 
     Returns:
       (found_errors, stderr) A boolean indicating whether errors were found and
           the raw Closure compiler stderr (as a string).
     """
     is_extern = lambda f: 'externs' in f
     externs_and_deps = [self._POLYMER_EXTERNS]
@@ skipping 27 matching lines @@
       meta_file = self._create_temp_file("\n".join(contents))
       self._log_debug("Meta file: %s" % meta_file)
 
       self._processor = processor.Processor(meta_file)
       self._expanded_file = self._create_temp_file(self._processor.contents)
       self._log_debug("Expanded file: %s" % self._expanded_file)
 
       js_args = [self._expanded_file]
 
     closure_args = closure_args or []
-    closure_args += ["summary_detail_level=3"]
+    closure_args += ["summary_detail_level=3", "continue_after_errors"]
 
     args = ["--externs=%s" % e for e in externs] + \
            ["--js=%s" % s for s in js_args] + \
            ["--%s" % arg for arg in closure_args]
 
     if out_file:
       out_dir = os.path.dirname(out_file)
       if not os.path.exists(out_dir):
         os.makedirs(out_dir)
       args += ["--js_output_file=%s" % out_file]
       args += ["--create_source_map=%s" % (self._MAP_FILE_FORMAT % out_file)]
 
-    args_file_content = " %s" % " ".join(args)
-    self._log_debug("Args: %s" % args_file_content.strip())
+    self._log_debug("Args: %s" % " ".join(args))
 
-    args_file = self._create_temp_file(args_file_content)
-    self._log_debug("Args file: %s" % args_file)
-
-    processed_runner_args = ["--%s" % arg for arg in runner_args or []]
-    processed_runner_args += ["--compiler-args-file=%s" % args_file]
-    _, stderr = self._run_jar(self._runner_jar, processed_runner_args)
+    _, stderr = self._run_jar(self._compiler_jar, args)
 
     errors = stderr.strip().split("\n\n")
     maybe_summary = errors.pop()
 
     summary = re.search("(?P<error_count>\d+).*error.*warning", maybe_summary)
     if summary:
       self._log_debug("Summary: %s" % maybe_summary)
     else:
       # Not a summary. Running the jar failed. Bail.
       self._log_error(stderr)
@@ skipping 23 matching lines @@
 
 if __name__ == "__main__":
   parser = argparse.ArgumentParser(
       description="Typecheck JavaScript using Closure compiler")
   parser.add_argument("sources", nargs=argparse.ONE_OR_MORE,
                       help="Path to a source file to typecheck")
   parser.add_argument("--custom_sources", action="store_true",
                       help="Whether this rules has custom sources.")
   parser.add_argument("-o", "--out_file",
                       help="A file where the compiled output is written to")
-  parser.add_argument("-r", "--runner_args", nargs=argparse.ZERO_OR_MORE,
-                      help="Arguments passed to runner.jar")
   parser.add_argument("-c", "--closure_args", nargs=argparse.ZERO_OR_MORE,
                       help="Arguments passed directly to the Closure compiler")
   parser.add_argument("-v", "--verbose", action="store_true",
                       help="Show more information as this script runs")
   opts = parser.parse_args()
 
   checker = Checker(verbose=opts.verbose)
 
   found_errors, stderr = checker.check(opts.sources, out_file=opts.out_file,
                                        closure_args=opts.closure_args,
-                                       runner_args=opts.runner_args,
                                        custom_sources=opts.custom_sources)
 
   if found_errors:
     if opts.custom_sources:
       print stderr
     sys.exit(1)