Add chrome_html gatherer, which inlines html and automatically generates image set…

grit/format/html_inline.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Flattens a HTML file by inlining its external resources.
 
 This is a small script that takes a HTML file, looks for src attributes
 and inlines the specified file, producing one HTML file with no external
 dependencies. It recursively inlines the included files.
@@ skipping 77 matching lines @@
   """Helper class holding the results from DoInline().
 
   Holds the inlined data and the set of filenames of all the inlined
   files.
   """
   def __init__(self, inlined_data, inlined_files):
     self.inlined_data = inlined_data
     self.inlined_files = inlined_files
 
 def DoInline(
-    input_filename, grd_node, allow_external_script=False, names_only=False):
+    input_filename, grd_node, allow_external_script=False, names_only=False,
+    rewrite_function=None):
   """Helper function that inlines the resources in a specified file.
 
   Reads input_filename, finds all the src attributes and attempts to
   inline the files they are referring to, then returns the result and
   the set of inlined files.
 
   Args:
     input_filename: name of file to read in
     grd_node: html node from the grd file for this include tag
     names_only: |nil| will be returned for the inlined contents (faster).
+    rewrite_function: function(filepath, text, distribution) which will be
+        called to rewrite html content before inlining images.
   Returns:
     a tuple of the inlined data as a string and the set of filenames
     of all the inlined files
   """
   input_filepath = os.path.dirname(input_filename)
 
   distribution = DIST_DEFAULT
   if DIST_ENV_VAR in os.environ.keys():
     distribution = os.environ[DIST_ENV_VAR]
     if len(distribution) > 1 and distribution[0] == '_':
@@ skipping 82 matching lines @@
   def InlineScript(match):
     """Helper function to inline external script files"""
     attrs = (match.group('attrs1') + match.group('attrs2')).strip()
     if attrs:
        attrs = ' ' + attrs
     return InlineFileContents(match, '<script' + attrs + '>%s</script>')
 
   def InlineCSSText(text, css_filepath):
     """Helper function that inlines external resources in CSS text"""
     filepath = os.path.dirname(css_filepath)
+    # Allow custom modifications before inlining images.
+    if rewrite_function:
+      text = rewrite_function(filepath, text, distribution)
     return InlineCSSImages(text, filepath)
 
   def InlineCSSFile(src_match, inlined_files=inlined_files):
     """Helper function to inline external css files.
 
     Args:
       src_match: A regular expression match with a named group named "filename".
 
     Returns:
       The text that should replace the reference to the CSS file.
     """
     filepath = GetFilepath(src_match)
     if filepath is None:
       return src_match.group(0)
 
     # Even if names_only is set, the CSS file needs to be opened, because it
     # can link to images that need to be added to the file set.
     inlined_files.add(filepath)
     # When resolving CSS files we need to pass in the path so that relative URLs
     # can be resolved.
     return '<style>%s</style>' % InlineCSSText(ReadFile(filepath), filepath)
 
   def InlineCSSImages(text, filepath=input_filepath):
     """Helper function that inlines external images in CSS backgrounds."""
     # Replace contents of url() for css attributes: content, background,
     # or *-image.
-    return re.sub('(?:content|background|[\w-]*-image):[ ]*' +
-                  'url\((?:\'|\")(?P<filename>[^"\'\)\(]*)(?:\'|\")',
+    return re.sub('(?:content|background|[\w-]*-image):[^;]*' +
+                  '(?:url\((?:\'|\")([^"\'\)\(]*)(?:\'|\")\)|' +
+                      'image-set\(' +
+                          '([ ]*url\((?:\'|\")([^"\'\)\(]*)(?:\'|\")\)' +
+                              '[ ]*[0-9.]*x[ ]*(,[ ]*)?)*\))',
+                  lambda m: InlineCSSUrls(m, filepath),
+                  text)
+
+  def InlineCSSUrls(src_match, filepath=input_filepath):
+    """Helper function that inlines each url on a CSS image rule match."""
+    # Replace contents of url() references in matches.
+    return re.sub('url\((?:\'|\")(?P<filename>[^"\'\)\(]*)(?:\'|\")',
                   lambda m: SrcReplace(m, filepath),
-                  text)
+                  src_match.group(0))
+
+
 
   flat_text = ReadFile(input_filename)
 
   if not allow_external_script:
     # We need to inline css and js before we inline images so that image
     # references gets inlined in the css and js
     flat_text = re.sub('<script (?P<attrs1>.*?)src="(?P<filename>[^"\']*)"' +
                        '(?P<attrs2>.*?)></script>',
                        InlineScript,
                        flat_text)
 
   flat_text = re.sub(
       '<link rel="stylesheet".+?href="(?P<filename>[^"]*)".*?>',
       InlineCSSFile,
       flat_text)
 
   flat_text = re.sub(
       '<include\s+src="(?P<filename>[^"\']*)".*>',
       InlineIncludeFiles,
       flat_text)
 
   # Check conditional elements, remove unsatisfied ones from the file.
   flat_text = CheckConditionalElements(flat_text)
 
   flat_text = re.sub('<(?!script)[^>]+?src="(?P<filename>[^"\']*)"',
                      SrcReplace,
                      flat_text)
 
+  # Allow custom modifications before inlining images.
+  if rewrite_function:
+    flat_text = rewrite_function(input_filepath, flat_text, distribution)
+
   # TODO(arv): Only do this inside <style> tags.
   flat_text = InlineCSSImages(flat_text)
 
   flat_text = re.sub('<link rel="icon".+?href="(?P<filename>[^"\']*)"',
                      SrcReplace,
                      flat_text)
 
   if names_only:
     flat_text = None  # Will contains garbage if the flag is set anyway.
   return InlinedData(flat_text, inlined_files)
 
 
-def InlineToString(input_filename, grd_node, allow_external_script=False):
+def InlineToString(input_filename, grd_node, allow_external_script=False,
+                   rewrite_function=None):
   """Inlines the resources in a specified file and returns it as a string.
 
   Args:
     input_filename: name of file to read in
     grd_node: html node from the grd file for this include tag
   Returns:
     the inlined data as a string
   """
   try:
     return DoInline(input_filename,
                     grd_node,
-                    allow_external_script=allow_external_script).inlined_data
+                    allow_external_script=allow_external_script,
+                    rewrite_function=rewrite_function).inlined_data
   except IOError, e:
     raise Exception("Failed to open %s while trying to flatten %s. (%s)" %
                     (e.filename, input_filename, e.strerror))
 
 
 def InlineToFile(input_filename, output_filename, grd_node):
   """Inlines the resources in a specified file and writes it.
 
   Reads input_filename, finds all the src attributes and attempts to
   inline the files they are referring to, then writes the result
@@ skipping 24 matching lines @@
 
 def main():
   if len(sys.argv) <= 2:
     print "Flattens a HTML file by inlining its external resources.\n"
     print "html_inline.py inputfile outputfile"
   else:
     InlineToFile(sys.argv[1], sys.argv[2], None)
 
 if __name__ == '__main__':
   main()