Teach grit that file.svg is an SVG.

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.
 """
 
 import os
 import re
 import sys
 import base64
 import mimetypes
 
 from grit import lazy_re
 from grit import util
 
 # There is a python bug that makes mimetypes crash if the Windows
 # registry contains non-Latin keys ( http://bugs.python.org/issue9291
 # ). Initing manually and blocking external mime-type databases will
-# prevent that bug and still give us the data we need.
+# prevent that bug and if we add svg manually, it will still give us
+# the data we need.
 mimetypes.init([])
+mimetypes.add_type('image/svg+xml', '.svg')
 
 DIST_DEFAULT = 'chromium'
 DIST_ENV_VAR = 'CHROMIUM_BUILD'
 DIST_SUBSTR = '%DISTRIBUTION%'
 
 # Matches beginning of an "if" block with trailing spaces.
 _BEGIN_IF_BLOCK = lazy_re.compile(
     '<if [^>]*?expr="(?P<expression>[^"]*)"[^>]*?>\s*')
 
 # Matches ending of an "if" block with preceding spaces.
 _END_IF_BLOCK = lazy_re.compile('\s*</if>')
 
 # Used by DoInline to replace various links with inline content.
 _STYLESHEET_RE = lazy_re.compile(
     '<link rel="stylesheet"[^>]+?href="(?P<filename>[^"]*)".*?>(\s*</link>)?',
     re.DOTALL)
 _INCLUDE_RE = lazy_re.compile(
     '<include[^>]+?src="(?P<filename>[^"\']*)".*?>(\s*</include>)?',
     re.DOTALL)
 _SRC_RE = lazy_re.compile(
     r'<(?!script)(?:[^>]+?\s)src=(?P<quote>")(?P<filename>[^"\']*)\1',
     re.MULTILINE)
 _ICON_RE = lazy_re.compile(
     r'<link rel="icon"\s(?:[^>]+?\s)?'
     'href=(?P<quote>")(?P<filename>[^"\']*)\1',
     re.MULTILINE)
 
 
-
-def FixupMimeType(mime_type):
-  """Helper function that normalizes platform differences in the mime type
-     returned by the Python's mimetypes.guess_type API.
-  """
-  mappings = {
-    'image/x-png': 'image/png'
-  }
-  return mappings[mime_type] if mime_type in mappings else mime_type
-
-
 def GetDistribution():
   """Helper function that gets the distribution we are building.
 
   Returns:
     string
   """
   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 32 matching lines @@
     # filename is probably a URL, which we don't want to bother inlining
     return src_match.group(0)
 
   filename = filename.replace(DIST_SUBSTR , distribution)
   filepath = os.path.normpath(os.path.join(base_path, filename))
   inlined_files.add(filepath)
 
   if names_only:
     return ""
 
-  mimetype = FixupMimeType(mimetypes.guess_type(filename)[0]) or 'text/plain'
+  mimetype = mimetypes.guess_type(filename)[0]
+  if mimetype is None:
+    raise Exception('%s is of an an unknown type and '
+                    'cannot be stored in a data url.' % filename)
   inline_data = base64.standard_b64encode(util.ReadFile(filepath, util.BINARY))
 
   prefix = src_match.string[src_match.start():src_match.start('filename')]
   suffix = src_match.string[src_match.end('filename'):src_match.end()]
   return '%sdata:%s;base64,%s%s' % (prefix, mimetype, inline_data, suffix)
 
 
 class InlinedData:
   """Helper class holding the results from DoInline().
 
@@ skipping 289 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()