Add keyword_subset field template and generate text-decoration-line.

third_party/WebKit/Source/build/scripts/make_computed_style_base.py

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 import math
 import sys
 
 import json5_generator
 import template_expander
 import make_style_builder
 
 from name_utilities import (
     enum_for_css_keyword, enum_type_name, enum_value_name, class_member_name, method_name,
     class_name, join_name
 )
-from collections import defaultdict, OrderedDict
+from collections import defaultdict
 from itertools import chain
 
 # Heuristic ordering of types from largest to smallest, used to sort fields by their alignment sizes.
 # Specifying the exact alignment sizes for each type is impossible because it's platform specific,
 # so we define an ordering instead.
 # The ordering comes from the data obtained in:
 # https://codereview.chromium.org/2841413002
 # TODO(shend): Put alignment sizes into code form, rather than linking to a CL which may disappear.
 ALIGNMENT_ORDER = [
     'double',
@@ skipping 39 matching lines @@
         self.type_name = class_name(join_name('style', name, 'data'))
         self.member_name = class_member_name(join_name(name, 'data'))
         self.num_32_bit_words_for_bit_fields = _num_32_bit_words_for_bit_fields(
             field for field in fields if field.is_bit_field
         )
 
         # Recursively get all the fields in the subgroups as well
         self.all_fields = _flatten_list(subgroup.all_fields for subgroup in subgroups) + fields
 
 
+class Enum(object):
+    """Represents a generated enum in ComputedStyleConstants."""

[nainar, 2017/05/30 04:13:45]

ComputedStyleBaseConstants

+    def __init__(self, type_name, keywords, is_set):
+        self.type_name = type_name
+        self.values = [enum_value_name(keyword) for keyword in keywords]
+        self.is_set = is_set

[nainar, 2017/05/30 04:13:45]

is_set -> is_subset

[shend, 2017/05/31 07:52:07]

I decided not to change this one, since the enum itself is a set. if
(enum.is_subset) looks weird.

+
+
 class DiffGroup(object):
     """Represents a group of expressions and subgroups that need to be diffed
     for a function in ComputedStyle.
 
     Attributes:
         subgroups: List of DiffGroup instances that are stored as subgroups under this group.
         expressions: List of expression that are on this group that need to be diffed.
     """
     def __init__(self, group_name):
         self.group_name = group_name
@@ skipping 133 matching lines @@
             if not field.is_inherited_flag and field.property_name in entry['field_dependencies']:
                 diff_group.expressions.append(entry['method'])
     for entry in predicates_to_test:
         for field in root_group.fields:
             if not field.is_inherited_flag and field.property_name in entry['field_dependencies']:
                 diff_group.predicates.append(entry['predicate'])
     return diff_group
 
 
 def _create_enums(properties):
-    """
-    Returns an OrderedDict of enums to be generated, enum name -> [list of enum values]
-    """
+    """Returns a list of Enums to be generated"""
     enums = {}
     for property_ in properties:
         # Only generate enums for keyword properties that do not require includes.
-        if property_['field_template'] == 'keyword' and len(property_['include_paths']) == 0:
-            enum_name = property_['type_name']
-            enum_values = [enum_value_name(k) for k in property_['keywords']]
+        if property_['field_template'] in ('keyword', 'keyword_set') and len(property_['include_paths']) == 0:

[nainar, 2017/05/30 04:13:45]

keyword_set -> keyword_subset

[shend, 2017/05/31 07:52:07]

done.

+            enum = Enum(property_['type_name'], property_['keywords'],
+                        is_set=(property_['field_template'] == 'keyword_set'))
 
-            if enum_name in enums:
+            if property_['field_template'] == 'keyword_set':
+                assert property_['keywords'][0] == 'none', \
+                    "First keyword in a 'keyword_set' field must be 'none' in '{}'.".format(property_['name'])
+
+            if enum.type_name in enums:
                 # There's an enum with the same name, check if the enum values are the same
-                assert set(enums[enum_name]) == set(enum_values), \
-                    ("'" + property_['name'] + "' can't have type_name '" + enum_name + "' "
+                assert set(enums[enum.type_name].values) == set(enum.values), \
+                    ("'" + property_['name'] + "' can't have type_name '" + enum.type_name + "' "
                      "because it was used by a previous property, but with a different set of keywords. "
                      "Either give it a different name or ensure the keywords are the same.")
 
-            enums[enum_name] = enum_values
+            enums[enum.type_name] = enum
 
-    # Return the enums sorted by key (enum name)
-    return OrderedDict(sorted(enums.items(), key=lambda t: t[0]))
+    # Return the enums sorted by type name
+    return list(sorted(enums.values(), key=lambda e: e.type_name))
 
 
 def _create_property_field(property_):
     """
     Create a property field.
     """
     name_for_methods = property_['name_for_methods']
 
     assert property_['default_value'] is not None, \
         ('MakeComputedStyleBase requires an default value for all fields, none specified '
          'for property ' + property_['name'])
 
     if property_['field_template'] == 'keyword':
         type_name = property_['type_name']
         default_value = type_name + '::' + enum_value_name(property_['default_value'])
         size = int(math.ceil(math.log(len(property_['keywords']), 2)))
+    elif property_['field_template'] == 'keyword_set':
+        type_name = property_['type_name']
+        default_value = type_name + '::' + enum_value_name(property_['default_value'])
+        size = len(property_['keywords']) - 1  # Subtract 1 for 'none' keyword
     elif property_['field_template'] == 'storage_only':
         # 'storage_only' fields need to specify a size, type_name and default_value
         type_name = property_['type_name']
         default_value = property_['default_value']
         size = property_['field_size']
     elif property_['field_template'] == 'external':
         type_name = property_['type_name']
         default_value = property_['default_value']
         size = None
     elif property_['field_template'] == 'primitive':
@@ skipping 180 matching lines @@
 
     @template_expander.use_jinja('ComputedStyleBaseConstants.h.tmpl')
     def generate_base_computed_style_constants(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
         }
 
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()