update w3c import script to actually work :).

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 22 matching lines @@
 from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup, Tag
 
 
 class W3CTestConverter(object):
 
     def __init__(self):
         self._host = Host()
         self._filesystem = self._host.filesystem
         self._host.initialize_scm()
         self._webkit_root = self._host.scm().checkout_root
+
+        # These settings might vary between WebKit and Blink
+        self._css_property_file = self.path_from_webkit_root('Source', 'core', 'css', 'CSSPropertyNames.in')
+        self._css_property_split_string = 'alias_for='
+
         self.prefixed_properties = self.read_webkit_prefixed_css_property_list()
 
     def path_from_webkit_root(self, *comps):
         return self._filesystem.abspath(self._filesystem.join(self._webkit_root, *comps))
 
     def read_webkit_prefixed_css_property_list(self):
         prefixed_properties = []
 
-        contents = self._filesystem.read_text_file(self.path_from_webkit_root('Source', 'core', 'css', 'CSSPropertyNames.in'))
+        contents = self._filesystem.read_text_file(self._css_property_file)
         for line in contents.splitlines():
             # Find lines starting with the -webkit- prefix.
             match = re.match('-webkit-[\w|-]*', line)
             if match:
                 # Ignore lines where both the prefixed and non-prefixed property
                 # are supported - denoted by -webkit-some-property = some-property.
-                fields = line.split('alias_for=')
+                fields = line.split(self._css_property_split_string)
                 if len(fields) == 2 and fields[1].strip() in fields[0].strip():
                     continue
                 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_text_file(filename)
+        contents = self._filesystem.read_binary_file(filename)

[Dirk Pranke, 2013/05/21 00:46:53]

Note: here and below, we need to open the files as binary because some of the
files have unicode byte order markers at the front :( . At some point hopefully
we can get that fixed.

         if filename.endswith('.css'):
             return self.convert_css(contents)
         return self.convert_html(new_path, contents)
 
     def convert_css(self, contents):
         return self.add_webkit_prefix_to_unprefixed_properties(contents)
 
     def convert_html(self, new_path, contents):
         doc = BeautifulSoup(contents)
         did_modify_paths = self.convert_testharness_paths(doc, new_path)
@@ skipping 11 matching lines @@
         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'
 
             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)
 
@@ skipping 36 matching lines @@
         return (converted_properties, doc.prettify())
 
     def add_webkit_prefix_to_unprefixed_properties(self, text):
         """ 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, too.
+        # 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()