Add ChromeCodingConvention.java to Closure Compiler to preserve getInstance() type

third_party/closure_compiler/compile_modules.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.
 
 import argparse
 from checker import Checker as Checker
 import os
+import sys
+
 try:
   import json
 except:
   import simplejson as json
 
 
 class Module(object):
   def __init__(self, name, sources, depends=[], externs=[]):
     self.name = name
     self.sources = sources
@@ skipping 19 matching lines @@
 # TODO(dbeam): should ModuleParser be internal to ModuleCompiler or should we
 # pass Modules into ModuleCompiler.compile()? Maybe this is fine?
 class ModuleParser(object):
   _cache = {}
 
   def __init__(self, verbose=False):
     self._verbose = verbose
 
   def parse(self, file_path):
     if file_path in self._cache:
-      print "(INFO) Found module file %s in the cache" % file_path 
+      print "(INFO) Found module file %s in the cache" % file_path
       return self._cache[file_path]
 
     file = open(file_path, "r")
     data = json.load(file)
     file.close()
 
     if self._verbose:
       pretty_json = json.dumps(data, indent=2, separators=(',', ': ')).strip()
       print "(INFO) Layout: " + os.linesep + pretty_json + os.linesep
 
@@ skipping 31 matching lines @@
         rel_path = lambda f: os.path.join(here_to_module_dir, f)
 
     modules = self._parser.parse(module_file)
 
     for m in modules:
       self._debug("MODULE: " + m.name, prefix="", suffix=os.linesep)
 
       for s in m.sources:
         depends = [rel_path(d) for d in m.depends]
         externs = [rel_path(e) for e in m.externs]
-        self._checker.check(rel_path(s), depends=depends, externs=externs)
+        exit_code, _ = self._checker.check(rel_path(s), depends=depends,
+                                           externs=externs)
+        if exit_code:
+          sys.exit(exit_code)
 
         if s != m.sources[-1]:
           self._debug(os.linesep, prefix="")
 
       if m != modules[-1]:
         self._debug(os.linesep, prefix="")
 
 
 def main(opts):
   module_compiler = ModuleCompiler(verbose=opts.verbose)
   for module_file in opts.module_file:
     module_compiler.compile(module_file)
 
 
 if __name__ == "__main__":
   parser = argparse.ArgumentParser(
       description="Typecheck JavaScript using Closure compiler")
   parser.add_argument("-v", "--verbose", action="store_true",
                       help="Show more information as this script runs")
   parser.add_argument("module_file", nargs=argparse.ONE_OR_MORE,
                       help="Path to a modules file to check")
   main(parser.parse_args())