Speed up test importing by doing all the regex matching in a single pass.

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 33 matching lines @@
         self._host = Host()
         self._filesystem = self._host.filesystem
         self._webkit_root = WebKitFinder(self._filesystem).webkit_base()
 
         # 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()
 
+        prop_regex = '([\s{]|^)(' + "|".join(prop.replace('-webkit-', '') for prop in self.prefixed_properties) + ')(\s+:|:)'
+        self.prop_re = re.compile(prop_regex)
+
     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 = []
         unprefixed_properties = set()
 
         contents = self._filesystem.read_text_file(self._css_property_file)
         for line in contents.splitlines():
             if re.match('^(#|//)', line):
@@ skipping 86 matching lines @@
                 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, filename)
 
             # Rewrite tag only if changes were made.
             if updated_style_text[0]:
-                converted_properties.extend(updated_style_text[0])
+                converted_properties.extend(list(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)
 
+        # FIXME: Doing the replace in the parsed document and then writing it back out
+        # is normalizing the HTML, which may in fact alter the intent of some tests.
+        # We should probably either just do basic string-replaces, or have some other
+        # way of flagging tests that are sensitive to being rewritten.
+        # https://bugs.webkit.org/show_bug.cgi?id=119159
+
         return (converted_properties, doc.prettify())
 
     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 = []
+        converted_properties = set()
+        text_chunks = []
+        cur_pos = 0
+        for m in self.prop_re.finditer(text):
+            text_chunks.extend([text[cur_pos:m.start()], m.group(1), '-webkit-', m.group(2), m.group(3)])
+            converted_properties.add(m.group(2))
+            cur_pos = m.end()
+        text_chunks.append(text[cur_pos:])
 
-        for raw_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.
-
-            # 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{]|^)' + raw_property + '(\s+:|:)'
-            if re.search(pattern, text):
-                replacement_property = '-webkit-%s' % raw_property
-                _log.info('converting %s -> %s' % (raw_property, replacement_property))
-                converted_properties.append(replacement_property)
-                text = re.sub(pattern, replacement_property + ':', text)
+        for prop in converted_properties:
+            _log.info('  converting %s', prop)
 
         # 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()