Generates predicates to test in diff functions in ComputedStyle

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 = [
     'double',
-    'AtomicString', 'RefPtr', 'Persistent', 'Font', 'FillLayer', 'NinePieceImage', 'LayoutUnit' # Aligns like a pointer (can be 32 or 64 bits)
+    'AtomicString', 'RefPtr', 'Persistent', 'Font', 'FillLayer', 'NinePieceImage',  # Aligns like a pointer (can be 32 or 64 bits)
     'LengthBox', 'LengthSize', 'Length', 'TextSizeAdjust', 'TabSize', 'float',
-    'StyleColor', 'Color', 'unsigned', 'int',
+    'StyleColor', 'Color', 'LayoutUnit', 'unsigned', 'int',
     'short',
     'uint8_t', 'char',
     'bool'
 ]
 
 # TODO(shend): Improve documentation and add docstrings.
 
 
 def _flatten_list(x):
     """Flattens a list of lists into a single list."""
@@ skipping 38 matching lines @@
     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
         self.subgroups = []
         self.expressions = []
+        self.predicates = []
 
 
 class Field(object):
     """
     The generated ComputedStyle object is made up of a series of Fields.
     Each Field has a name, size, type, etc, and a bunch of attributes to
     determine which methods it will be used in.
 
     A Field also has enough information to use any storage type in C++, such as
     regular member variables, or more complex storage like vectors or hashmaps.
@@ skipping 86 matching lines @@
         groups[field.group_name].append(field)
 
     no_group = groups.pop(None)
     subgroups = [Group(group_name, [], _reorder_fields(fields)) for group_name, fields in groups.items()]
     return Group('', subgroups=subgroups, fields=_reorder_fields(no_group))
 
 
 def _create_diff_groups_map(diff_function_inputs, root_group):
     diff_functions_map = {}
     for entry in diff_function_inputs:
-        diff_functions_map[entry['name']] = _create_diff_groups(entry['fields_to_diff'], entry['methods_to_diff'], root_group)
+        diff_functions_map[entry['name']] = _create_diff_groups(entry['fields_to_diff'],
+                                                                entry['methods_to_diff'], entry['predicates_to_test'], root_group)
     return diff_functions_map
 
 
-def _list_field_dependencies(methods_to_diff):
+def _list_field_dependencies(entries_with_field_dependencies):
     field_dependencies = []
-    for entry in methods_to_diff:
+    for entry in entries_with_field_dependencies:
         field_dependencies += entry['field_dependencies']
     return field_dependencies
 
 
-def _create_diff_groups(fields_to_diff, methods_to_diff, root_group):
+def _create_diff_groups(fields_to_diff, methods_to_diff, predicates_to_test, root_group):
     diff_group = DiffGroup(root_group.member_name)
-    field_dependencies = _list_field_dependencies(methods_to_diff)
+    field_dependencies = _list_field_dependencies(methods_to_diff + predicates_to_test)
     for subgroup in root_group.subgroups:
         if any(field.property_name in (fields_to_diff + field_dependencies) for field in subgroup.all_fields):
-            diff_group.subgroups.append(_create_diff_groups(fields_to_diff, methods_to_diff, subgroup))
+            diff_group.subgroups.append(_create_diff_groups(fields_to_diff, methods_to_diff, predicates_to_test, subgroup))
     for field in root_group.fields:
         if field.property_name in fields_to_diff:
             diff_group.expressions.append(field.getter_expression)
         for entry in methods_to_diff:
             if field.property_name in entry['field_dependencies']:
                 diff_group.expressions.append(entry['method'])
+        for entry in predicates_to_test:
+            if 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]
     """
     enums = {}
     for property_ in properties:
         # Only generate enums for keyword properties that use the default field_type_path.
@@ skipping 223 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()