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 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 = [
     # Aligns like double
@@ skipping 74 matching lines @@
         and so on.
         """
         group_path = []
         current_group = self
         while current_group.name:
             group_path.insert(0, current_group)
             current_group = current_group.parent
         return group_path
 
 
+class Enum(object):
+    """Represents a generated enum in 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
+
+
 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):
         self.group = group
@@ skipping 165 matching lines @@
                 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']
                     and entry['predicate'] not in diff_group.predicates):
                 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', 'multi_keyword') and len(property_['include_paths']) == 0:
+            enum = Enum(property_['type_name'], property_['keywords'],
+                        is_set=(property_['field_template'] == 'multi_keyword'))
 
-            if enum_name in enums:
+            if property_['field_template'] == 'multi_keyword':
+                assert property_['keywords'][0] == 'none', \
+                    "First keyword in a 'multi_keyword' 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'])
         assert property_['field_size'] is None, \
             ("'" + property_['name'] + "' is a keyword field, "
              "so it should not specify a field_size")
         size = int(math.ceil(math.log(len(property_['keywords']), 2)))
+    elif property_['field_template'] == 'multi_keyword':
+        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':
         type_name = property_['type_name']
         default_value = property_['default_value']
         size = 1 if type_name == 'bool' else 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':
         type_name = property_['type_name']
@@ skipping 196 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()