Closure: convert the rest of chrome/browser/resources/ to v2 GYP

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 171 matching lines @@
 
     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, closure_args=None,
-            custom_sources=True):
+            custom_sources=True, custom_includes=False):
     """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.
       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]
 
     if custom_sources:
+      if custom_includes:
+        # TODO(dbeam): this is fairly hacky. Can we just remove custom_sources
+        # soon when all the things kept on life support using it die?
+        self._target = sources.pop()
       externs_and_deps += sources
     else:
       self._target = sources[0]
       externs_and_deps += sources[1:]
 
     externs = filter(is_extern, externs_and_deps)
     deps = filter(lambda f: not is_extern(f), externs_and_deps)
 
     assert externs or deps or self._target
 
     self._log_debug("Externs: %s" % externs)
     self._log_debug("Dependencies: %s" % deps)
     self._log_debug("Target: %s" % self._target)
 
     js_args = deps + ([self._target] if self._target else [])
 
-    if not custom_sources:
+    process_includes = custom_includes or not custom_sources
+    if process_includes:
       # TODO(dbeam): compiler.jar automatically detects "@externs" in a --js arg
       # and moves these files to a different AST tree. However, because we use
       # one big funky <include> meta-file, it thinks all the code is one big
       # externs. Just use --js when <include> dies.
 
       cwd, tmp_dir = os.getcwd(), tempfile.gettempdir()
       rel_path = lambda f: os.path.join(os.path.relpath(cwd, tmp_dir), f)
       contents = ['<include src="%s">' % rel_path(f) for f in js_args]
       meta_file = self._create_temp_file("\n".join(contents))
       self._log_debug("Meta file: %s" % meta_file)
@@ skipping 44 matching lines @@
         os.remove(out_file)
       if os.path.exists(self._MAP_FILE_FORMAT % out_file):
         os.remove(self._MAP_FILE_FORMAT % out_file)
     elif checks_only:
       # Compile succeeded but --checks_only disables --js_output_file from
       # actually writing a file. Write a file ourselves so incremental builds
       # still work.
       with open(out_file, 'w') as f:
         f.write('')
 
-    if not custom_sources:
+    if process_includes:
       filtered_errors = self._filter_errors(errors)
       errors = map(self._clean_up_error, filtered_errors)
       output = self._format_errors(errors)
 
       if errors:
         prefix = "\n" if output else ""
         self._log_error("Error in: %s%s%s" % (self._target, prefix, output))
       elif output:
         self._log_debug("Output: %s" % output)
 
     self._nuke_temp_files()
     return bool(errors), stderr
 
 
 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("--custom_includes", action="store_true",
+                      help="If present, <include>s are processed when"
+                           "using --custom_files.")
   parser.add_argument("-o", "--out_file", required=True,
                       help="A file where the compiled output is written to")
   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,
-                                       custom_sources=opts.custom_sources)
+                                       custom_sources=opts.custom_sources,
+                                       custom_includes=opts.custom_includes)
 
   if found_errors:
     if opts.custom_sources:
       print stderr
     sys.exit(1)