Remove Chromium's custom closure runner.

third_party/closure_compiler/compiler_test.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 from ast import literal_eval
 import os
 import tempfile
 import unittest
 
 from compile import Checker
 from processor import FileCache, Processor
 
 
 _SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 _SRC_DIR = os.path.join(_SCRIPT_DIR, os.pardir, os.pardir)
 _RESOURCES_DIR = os.path.join(_SRC_DIR, "ui", "webui", "resources", "js")
 _ASSERT_JS = os.path.join(_RESOURCES_DIR, "assert.js")
 _CR_JS = os.path.join(_RESOURCES_DIR, "cr.js")
 _CR_UI_JS = os.path.join(_RESOURCES_DIR, "cr", "ui.js")
 _PROMISE_RESOLVER_JS = os.path.join(_RESOURCES_DIR, "promise_resolver.js")
 _POLYMER_EXTERNS = os.path.join(_SCRIPT_DIR, "externs", "polymer-1.0.js")
 _CHROME_SEND_EXTERNS = os.path.join(_SRC_DIR, "third_party", "closure_compiler",
                                     "externs", "chrome_send.js")
 _CLOSURE_ARGS_GYPI = os.path.join(_SCRIPT_DIR, "closure_args.gypi")
 _GYPI_DICT = literal_eval(open(_CLOSURE_ARGS_GYPI).read())
 _COMMON_CLOSURE_ARGS = _GYPI_DICT["default_closure_args"] + \
                        _GYPI_DICT["default_disabled_closure_args"]
-_RUNNER_ARGS = ["enable-chrome-pass"]
 
 class CompilerTest(unittest.TestCase):
   _ASSERT_DEFINITION = Processor(_ASSERT_JS).contents
   _PROMISE_RESOLVER_DEFINITION = (_ASSERT_DEFINITION +
                                   Processor(_PROMISE_RESOLVER_JS).contents)
   _CR_DEFINE_DEFINITION = (_PROMISE_RESOLVER_DEFINITION +
                            Processor(_CR_JS).contents)
   _CR_UI_DECORATE_DEFINITION = Processor(_CR_UI_JS).contents
 
   def setUp(self):
     self._checker = Checker()
     self._tmp_files = []
 
   def tearDown(self):
     for file in self._tmp_files:
       if os.path.exists(file):
         os.remove(file)
 
-  def _runChecker(self, source_code, closure_args=None):
+  def _runChecker(self, source_code, needs_output, closure_args=None):
     file_path = "/script.js"
     FileCache._cache[file_path] = source_code
     out_file, out_map = self._createOutFiles()
     args = _COMMON_CLOSURE_ARGS + (closure_args or [])
+    if needs_output:
+      args.remove("checks_only")
 
     externs = [_POLYMER_EXTERNS, _CHROME_SEND_EXTERNS]
     found_errors, stderr = self._checker.check(file_path,
                                                externs=externs,
                                                out_file=out_file,
-                                               runner_args=_RUNNER_ARGS,
                                                closure_args=args)
     return found_errors, stderr, out_file, out_map
 
   def _runCheckerTestExpectError(self, source_code, expected_error,
                                  closure_args=None):
-    _, stderr, out_file, out_map = self._runChecker(source_code, closure_args)
+    _, stderr, out_file, out_map = self._runChecker(
+        source_code, needs_output=False, closure_args=closure_args)
 
     self.assertTrue(expected_error in stderr,
         msg="Expected chunk: \n%s\n\nOutput:\n%s\n" % (
             expected_error, stderr))
     self.assertFalse(os.path.exists(out_file))
     self.assertFalse(os.path.exists(out_map))
 
   def _runCheckerTestExpectSuccess(self, source_code, expected_output=None,
                                    closure_args=None):
-    found_errors, stderr, out_file, out_map = self._runChecker(source_code,
-                                                               closure_args)
+    found_errors, stderr, out_file, out_map = self._runChecker(
+        source_code, needs_output=True, closure_args=closure_args)
 
     self.assertFalse(found_errors,
         msg="Expected success, but got failure\n\nOutput:\n%s\n" % stderr)
 
     self.assertTrue(os.path.exists(out_map))
     self.assertTrue(os.path.exists(out_file))
     if expected_output:
       with open(out_file, "r") as file:
         self.assertEquals(file.read(), expected_output)
 
@@ skipping 228 matching lines @@
       f.write("""
 goog.require('testScript');
 
 testScript();
 """)
     self._tmp_files.append(source_file2.name)
 
     out_file, out_map = self._createOutFiles()
     sources = [source_file1.name, source_file2.name]
     externs = [_POLYMER_EXTERNS]
+    closure_args = [a for a in _COMMON_CLOSURE_ARGS if a != "checks_only"]
     found_errors, stderr = self._checker.check_multiple(
-        sources, externs=externs, out_file=out_file,
-        closure_args=_COMMON_CLOSURE_ARGS)
+        sources, externs=externs, out_file=out_file, closure_args=closure_args)
     self.assertFalse(found_errors,
         msg="Expected success, but got failure\n\nOutput:\n%s\n" % stderr)
 
     expected_output = "'use strict';var testScript=function(){};testScript();\n"
     self.assertTrue(os.path.exists(out_map))
     self.assertTrue(os.path.exists(out_file))
     with open(out_file, "r") as file:
       self.assertEquals(file.read(), expected_output)
 
   def testExportPath(self):
@@ skipping 30 matching lines @@
 """
     args = ['warning_level=VERBOSE']
     self._runCheckerTestExpectError(template % '', 'Missing return',
                                     closure_args=args)
     self._runCheckerTestExpectSuccess(template % 'assertNotReached();',
                                       closure_args=args)
 
 
 if __name__ == "__main__":
   unittest.main()