Enable test_converter.py to import CSS Writing Modes test suites

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
 #    disclaimer.
 # 2. Redistributions in binary form must reproduce the above
 #    copyright notice, this list of conditions and the following
 #    disclaimer in the documentation and/or other materials
 #    provided with the distribution.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
 # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 # OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 # SUCH DAMAGE.
 
+import itertools
 import logging
 import re
 
 from webkitpy.common.host import Host
 from webkitpy.common.webkit_finder import WebKitFinder
 from HTMLParser import HTMLParser
 
 
 _log = logging.getLogger(__name__)
 
@@ skipping 28 matching lines @@
         self.reference_support_info = reference_support_info
 
         resources_path = self.path_from_webkit_root('LayoutTests', 'resources')
         resources_relpath = self._filesystem.relpath(resources_path, new_path)
         self.resources_relpath = resources_relpath
 
         # These settings might vary between WebKit and Blink
         self._css_property_file = self.path_from_webkit_root('Source', 'core', 'css', 'CSSProperties.in')
 
         self.prefixed_properties = self.read_webkit_prefixed_css_property_list()
+        self.prefixed_values = {
+            'unicode-bidi': ['isolate', 'isolate-override', 'plaintext']
+        }
+        self.renamed_properties = {
+            'text-combine-upright': '-webkit-text-combine'
+        }
+        self.renamed_values = {
+            'text-combine-upright': {'all': 'horizontal'}

[Dirk Pranke, 2015/05/27 22:52:59]

Is there a reason we can't just add support for the w3c's latest property names
and values instead of rewriting to use the old ones?

[kojii, 2015/05/27 23:47:38]

Replied above.

+        }

[Dirk Pranke, 2015/05/27 22:52:59]

this section could use some comments describing specifically what each field
will do, e.g.

prefixed_properties is a list of properties where we will add "-webkit-" on the
front of each name.

prefixed_values is a map of properties where the name stays the same (does it?)
but we prefix each value.

renamed_properties is a map where simply adding a prefix isn't good enough.

etc.

[kojii, 2015/05/27 23:47:38]

I'll add and re-upload, but allow me to reply as there are other points to
discuss.

 
-        self.prefixed_properties = self.read_webkit_prefixed_css_property_list()
-        prop_regex = '([\s{]|^)(' + "|".join(prop.replace('-webkit-', '') for prop in self.prefixed_properties) + ')(\s+:|:)'
+        prop_regex = '([\s{]|^)(' + "|".join(itertools.chain(
+            self.renamed_properties.iterkeys(),
+            self.renamed_values.iterkeys(),
+            self.prefixed_values.iterkeys(),
+            (prop.replace('-webkit-', '') for prop in self.prefixed_properties))) + ')(\s+:|:[^;]*)'
         self.prop_re = re.compile(prop_regex)
 
     def output(self):
         return (self.converted_properties, ''.join(self.converted_data))
 
     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):
                 # skip comments and preprocessor directives
                 continue
             prop = line.split()[0]
             # Find properties starting with the -webkit- prefix.
             match = re.match('-webkit-([\w|-]*)', prop)
             if match:
                 prefixed_properties.append(match.group(1))
             else:
                 unprefixed_properties.add(prop.strip())
 
+        # SVG writing-mode exists, but CSS writing-mode is still prefixed
+        unprefixed_properties.discard('writing-mode')

[Dirk Pranke, 2015/05/27 22:52:59]

I don't think I understand this change; if we still want writing-mode to be
prefixed, shouldn't we fix CSSProperties.in instead? 

[kojii, 2015/05/27 23:47:38]

There are two properties, "writing-mode" and "-webkit-writing-mode". The former
is in SVG REC, and applies only within SVG context. The latter is in CSS,
applies only in HTML context. So both properties exist, but we need to prefix to
test CSS writing-mode.

In 3-6 months I'm planning to plan unprefixing CSS Writing Modes, and I need to
come up with a plan to solve this problem. This is likely to break some content,
so I need more investigation and discussion, but I'd like to make sure our
layout code is stable enough to unprefix before making decisions on the uprefix
plan, and importing tests is to help that.

One of the discussion at www-style is here:
https://lists.w3.org/Archives/Public/www-style/2015May/0150.html

[Dirk Pranke, 2015/05/28 01:25:49]

Will this likely cause problems if we import some SVG tests, then?

+
         # Ignore any prefixed properties for which an unprefixed version is supported
-        return [prop for prop in prefixed_properties if prop not in unprefixed_properties]
+        return set(prop for prop in prefixed_properties if prop not in unprefixed_properties)

[Dirk Pranke, 2015/05/27 22:52:59]

why did this change to a set() ?

[kojii, 2015/05/27 23:47:38]

Because line #139 uses "in" operator to check if the property needs prefix. It's
not needed before because all properties in regexp should be prefixed before
this change. Now we include value prefix etc. too, so we need to check whether
to prefix or not.

[Dirk Pranke, 2015/05/28 01:25:49]

Okay. `in` actually works with both lists and sets, so I think the change is not
technically needed, but it's probably a reasonable optimization, so that's fine.

 
     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 = 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))
+            text_chunks.extend([text[cur_pos:m.start()], m.group(1)])
+            property = m.group(2)
+            oldProperty = self.renamed_properties.get(property)
+            if oldProperty:
+                text_chunks.append(oldProperty)
+            elif property in self.prefixed_properties:
+                text_chunks.extend(['-webkit-', property])
+            else:
+                text_chunks.append(property)
+            text_chunks.append(self.add_webkit_prefix_to_unprefixed_value(property, m.group(3)))
+            converted_properties.add(property)
             cur_pos = m.end()
         text_chunks.append(text[cur_pos:])
 
         for prop in converted_properties:
             _log.info('  converting %s', prop)
 
         # FIXME: Handle the JS versions of these properties and GetComputedStyle, too.
         return (converted_properties, ''.join(text_chunks))
 
+    def add_webkit_prefix_to_unprefixed_value(self, property, text):
+        renamed_values = self.renamed_values.get(property)
+        if renamed_values:
+            text = re.sub("|".join(renamed_values.iterkeys()), lambda m: renamed_values[m.group(0)], text)
+        prefixed_values = self.prefixed_values.get(property)
+        if prefixed_values:
+            text = re.sub("|".join(prefixed_values), lambda m: '-webkit-' + m.group(0), text)
+        return text
+
     def convert_reference_relpaths(self, text):
         """ Searches |text| for instances of files in reference_support_info and updates the relative path to be correct for the new ref file location"""
 
         converted = text
         for path in self.reference_support_info['files']:
             if text.find(path) != -1:
                 # FIXME: This doesn't handle an edge case where simply removing the relative path doesn't work.
                 # See crbug.com/421584 for details.
                 new_path = re.sub(self.reference_support_info['reference_relpath'], '', path, 1)
                 converted = re.sub(path, new_path, text)
@@ skipping 73 matching lines @@
         self.converted_data.extend(['&#', name, ';'])
 
     def handle_comment(self, data):
         self.converted_data.extend(['<!-- ', data, ' -->'])
 
     def handle_decl(self, decl):
         self.converted_data.extend(['<!', decl, '>'])
 
     def handle_pi(self, data):
         self.converted_data.extend(['<?', data, '>'])