Modify w3c import script to be able to run over a whole repo.

Tools/Scripts/webkitpy/w3c/test_converter.py

 #!/usr/bin/env python
 
 # Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the above
 #    copyright notice, this list of conditions and the following
@@ skipping 55 matching lines @@
                 prefixed_properties.append(match.group(0))
 
         return prefixed_properties
 
     def convert_for_webkit(self, new_path, filename):
         """ Converts a file's |contents| so it will function correctly in its |new_path| in Webkit.
 
         Returns the list of modified properties and the modified text if the file was modifed, None otherwise."""
         contents = self._filesystem.read_binary_file(filename)
         if filename.endswith('.css'):
-            return self.convert_css(contents)
-        return self.convert_html(new_path, contents)
+            return self.convert_css(contents, filename)
+        return self.convert_html(new_path, contents, filename)
 
-    def convert_css(self, contents):
-        return self.add_webkit_prefix_to_unprefixed_properties(contents)
+    def convert_css(self, contents, filename):
+        return self.add_webkit_prefix_to_unprefixed_properties(contents, filename)
 
-    def convert_html(self, new_path, contents):
+    def convert_html(self, new_path, contents, filename):
         doc = BeautifulSoup(contents)
-        did_modify_paths = self.convert_testharness_paths(doc, new_path)
-        converted_properties_and_content = self.convert_prefixed_properties(doc)
+        did_modify_paths = self.convert_testharness_paths(doc, new_path, filename)
+        converted_properties_and_content = self.convert_prefixed_properties(doc, filename)
         return converted_properties_and_content if (did_modify_paths or converted_properties_and_content[0]) else None
 
-    def convert_testharness_paths(self, doc, new_path):
+    def convert_testharness_paths(self, doc, new_path, filename):
         """ Update links to testharness.js in the BeautifulSoup |doc| to point to the copy in |new_path|.
 
         Returns whether the document was modified."""
 
         # Look for the W3C-style path to any testharness files - scripts (.js) or links (.css)
         pattern = re.compile('/resources/testharness')
         script_tags = doc.findAll(src=pattern)
         link_tags = doc.findAll(href=pattern)
         testharness_tags = script_tags + link_tags
 
         if not testharness_tags:
             return False
 
         resources_path = self.path_from_webkit_root('LayoutTests', 'resources')
         resources_relpath = self._filesystem.relpath(resources_path, new_path)
 
         for tag in testharness_tags:
             # FIXME: We need to handle img, audio, video tags also.
             attr = 'src'
             if tag.name != 'script':
                 attr = 'href'
 
+            if not attr in tag:
+                # FIXME: Figure out what to do w/ invalid tags. For now, we return False
+                # and leave the document unmodified, which means that it'll probably fail to run.
+                print "Error: missing an attr in %s" % filename
+                return False
+
             old_path = tag[attr]
             new_tag = Tag(doc, tag.name, tag.attrs)
             new_tag[attr] = re.sub(pattern, resources_relpath + '/testharness', old_path)
 
             self.replace_tag(tag, new_tag)
 
         return True
 
-    def convert_prefixed_properties(self, doc):
+    def convert_prefixed_properties(self, doc, filename):
         """ Searches a BeautifulSoup |doc| for any CSS properties requiring the -webkit- prefix and converts them.
 
         Returns the list of converted properties and the modified document as a string """
 
         converted_properties = []
 
         # Look for inline and document styles.
         inline_styles = doc.findAll(style=re.compile('.*'))
         style_tags = doc.findAll('style')
         all_styles = inline_styles + style_tags
 
         for tag in all_styles:
 
             # Get the text whether in a style tag or style attribute.
             style_text = ''
             if tag.name == 'style':
                 if not tag.contents:
                     continue
                 style_text = tag.contents[0]
             else:
                 style_text = tag['style']
 
-            updated_style_text = self.add_webkit_prefix_to_unprefixed_properties(style_text)
+            updated_style_text = self.add_webkit_prefix_to_unprefixed_properties(style_text, filename)
 
             # Rewrite tag only if changes were made.
             if updated_style_text[0]:
                 converted_properties.extend(updated_style_text[0])
 
                 new_tag = Tag(doc, tag.name, tag.attrs)
                 new_tag.insert(0, updated_style_text[1])
 
                 self.replace_tag(tag, new_tag)
 
         return (converted_properties, doc.prettify())
 
-    def add_webkit_prefix_to_unprefixed_properties(self, text):
+    def add_webkit_prefix_to_unprefixed_properties(self, text, filename):
         """ Searches |text| for instances of properties requiring the -webkit- prefix and adds the prefix to them.
 
         Returns the list of converted properties and the modified text."""
 
         converted_properties = []
 
         for prefixed_property in self.prefixed_properties:
             # FIXME: add in both the prefixed and unprefixed versions, rather than just replacing them?
             # That might allow the imported test to work in other browsers more easily.
 
             unprefixed_property = prefixed_property.replace('-webkit-', '')
 
             # Look for the various ways it might be in the CSS
             # Match the the property preceded by either whitespace or left curly brace
             # or at the beginning of the string (for inline style attribute)
             pattern = '([\s{]|^)' + unprefixed_property + '(\s+:|:)'
             if re.search(pattern, text):
                 print 'converting %s -> %s' % (unprefixed_property, prefixed_property)
                 converted_properties.append(prefixed_property)
                 text = re.sub(pattern, prefixed_property + ':', text)
 
         # FIXME: Handle the JS versions of these properties and GetComputedStyle, too.
         return (converted_properties, text)
 
     def replace_tag(self, old_tag, new_tag):
         index = old_tag.parent.contents.index(old_tag)
         old_tag.parent.insert(index, new_tag)
         old_tag.extract()