Refactor make_computed_style_base.py Field class to link to a Group.

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
@@ skipping 55 matching lines @@
         self.fields = fields
         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
 
+        # Link group
+        for field in fields:
+            field.group = self
+
 
 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
         self.subgroups = []
+        self.fields = []
         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.
     Almost all properties will have at least one Field, often more than one.
 
     Most attributes in this class correspond to parameters in CSSProperties.json5.
     See that file for a more detailed explanation of each attribute.
 
     Attributes:
         field_role: The semantic role of the field. Can be:
             - 'property': for fields that store CSS properties
             - 'inherited_flag': for single-bit flags that store whether a property is
                                 inherited by this style or set explicitly
         name_for_methods: String used to form the names of getters and setters.
             Should be in upper camel case.
         property_name: Name of the property that the field is part of.
         type_name: Name of the C++ type exposed by the generated interface (e.g. EClear, int).
         wrapper_pointer_name: Name of the pointer type that wraps this field (e.g. RefPtr).
         field_template: Determines the interface generated for the field. Can be one of:
            keyword, flag, or monotonic_flag.
-        field_group: The name of the group that this field is inside.
         size: Number of bits needed for storage.
         default_value: Default value for this field when it is first initialized.
     """
 
     def __init__(self, field_role, name_for_methods, property_name, type_name, wrapper_pointer_name,
-                 field_template, field_group, size, default_value, custom_copy, custom_compare,
+                 field_template, size, default_value, custom_copy, custom_compare,
                  getter_method_name, setter_method_name, initial_method_name, **kwargs):
         """Creates a new field."""
         self.name = class_member_name(name_for_methods)
         self.property_name = property_name
         self.type_name = type_name
         self.wrapper_pointer_name = wrapper_pointer_name
         self.alignment_type = self.wrapper_pointer_name or self.type_name
         self.field_template = field_template
-        self.group_name = field_group
-        self.group_member_name = class_member_name(join_name(field_group, 'data')) if field_group else None
         self.size = size
         self.default_value = default_value
         self.custom_copy = custom_copy
         self.custom_compare = custom_compare
+        self.group = None
 
         # Field role: one of these must be true
         self.is_property = field_role == 'property'
         self.is_inherited_flag = field_role == 'inherited_flag'
         assert (self.is_property, self.is_inherited_flag).count(True) == 1, \
             'Field role has to be exactly one of: property, inherited_flag'
 
         if not self.is_inherited_flag:
             self.is_inherited = kwargs.pop('inherited')
             self.is_independent = kwargs.pop('independent')
             assert self.is_inherited or not self.is_independent, 'Only inherited fields can be independent'
 
             self.is_inherited_method_name = method_name(join_name(name_for_methods, 'is inherited'))
 
         # Method names
         # TODO(nainar): Method name generation is inconsistent. Fix.
         self.getter_method_name = getter_method_name
         self.setter_method_name = setter_method_name
         self.internal_getter_method_name = method_name(join_name(self.name, 'Internal'))
         self.internal_mutable_method_name = method_name(join_name('Mutable', name_for_methods, 'Internal'))
         self.internal_setter_method_name = method_name(join_name(setter_method_name, 'Internal'))
         self.initial_method_name = initial_method_name
         self.resetter_method_name = method_name(join_name('Reset', name_for_methods))
-        if self.group_name:
-            self.getter_expression = self.group_member_name + '->' + class_member_name(self.name)
-        else:
-            self.getter_expression = class_member_name(self.name)
 
         # If the size of the field is not None, it means it is a bit field
         self.is_bit_field = self.size is not None
 
         assert len(kwargs) == 0, 'Unexpected arguments provided to Field: ' + str(kwargs)
 
 
 def _get_include_paths(properties):
     """
     Get a list of paths that need to be included for ComputedStyleBase.
     """
     include_paths = set()
     for property_ in properties:
         include_paths.update(property_['include_paths'])
     return list(sorted(include_paths))
 
 
-def _group_fields(fields):
+def _create_groups(properties):
     """Groups a list of fields by their group_name and returns the root group."""
     groups = defaultdict(list)
-    for field in fields:
-        groups[field.group_name].append(field)
+    for property_ in properties:
+        groups[property_['field_group']].extend(_create_fields(property_))
 
     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'],
@@ skipping 10 matching lines @@
 
 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 + 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, predicates_to_test, subgroup))
     for entry in fields_to_diff:
         for field in root_group.fields:
             if not field.is_inherited_flag and entry == field.property_name:
-                diff_group.expressions.append(field.getter_expression)
+                diff_group.fields.append(field)
     for entry in methods_to_diff:
         for field in root_group.fields:
             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
 
@@ skipping 61 matching lines @@
 
     return Field(
         'property',
         name_for_methods,
         property_name=property_['name'],
         inherited=property_['inherited'],
         independent=property_['independent'],
         type_name=type_name,
         wrapper_pointer_name=property_['wrapper_pointer_name'],
         field_template=property_['field_template'],
-        field_group=property_['field_group'],
         size=size,
         default_value=default_value,
         custom_copy=property_['custom_copy'],
         custom_compare=property_['custom_compare'],
         getter_method_name=property_['getter'],
         setter_method_name=property_['setter'],
         initial_method_name=property_['initial'],
     )
 
 
 def _create_inherited_flag_field(property_):
     """
     Create the field used for an inheritance fast path from an independent CSS property,
     and return the Field object.
     """
     name_for_methods = join_name(property_['name_for_methods'], 'is inherited')
     return Field(
         'inherited_flag',
         name_for_methods,
         property_name=property_['name'],
         type_name='bool',
         wrapper_pointer_name=None,
         field_template='primitive',
-        field_group=property_['field_group'],
         size=1,
         default_value='true',
         custom_copy=False,
         custom_compare=False,
         getter_method_name=method_name(name_for_methods),
         setter_method_name=method_name(join_name('set', name_for_methods)),
         initial_method_name=method_name(join_name('initial', name_for_methods)),
     )
 
 
-def _create_fields(properties):
+def _create_fields(property_):
     """
-    Create ComputedStyle fields from properties and return a list of Field objects.
+    Create ComputedStyle fields from a property and return a list of Field objects.
     """
     fields = []
-    for property_ in properties:
-        # Only generate properties that have a field template
-        if property_['field_template'] is not None:
-            # If the property is independent, add the single-bit sized isInherited flag
-            # to the list of Fields as well.
-            if property_['independent']:
-                fields.append(_create_inherited_flag_field(property_))
+    # Only generate properties that have a field template
+    if property_['field_template'] is not None:
+        # If the property is independent, add the single-bit sized isInherited flag
+        # to the list of Fields as well.
+        if property_['independent']:
+            fields.append(_create_inherited_flag_field(property_))
 
-            fields.append(_create_property_field(property_))
+        fields.append(_create_property_field(property_))
 
     return fields
 
 
 def _reorder_bit_fields(bit_fields):
     # Since fields cannot cross word boundaries, in order to minimize
     # padding, group fields into buckets so that as many buckets as possible
     # are exactly 32 bits. Although this greedy approach may not always
     # produce the optimal solution, we add a static_assert to the code to
     # ensure ComputedStyleBase results in the expected size. If that
@@ skipping 65 matching lines @@
             default_parameters=self.json5_file.parameters
         ).name_dictionaries
 
         for property_ in extra_fields:
             make_style_builder.apply_property_naming_defaults(property_)
 
         all_properties = css_properties + extra_fields
 
         self._generated_enums = _create_enums(all_properties)
 
-        all_fields = _create_fields(all_properties)
-
         # Organise fields into a tree structure where the root group
         # is ComputedStyleBase.
-        self._root_group = _group_fields(all_fields)
+        self._root_group = _create_groups(all_properties)
         self._diff_functions_map = _create_diff_groups_map(json5_generator.Json5File.load_from_files(
             [json5_file_paths[2]]
         ).name_dictionaries, self._root_group)
 
         self._include_paths = _get_include_paths(all_properties)
         self._outputs = {
             'ComputedStyleBase.h': self.generate_base_computed_style_h,
             'ComputedStyleBase.cpp': self.generate_base_computed_style_cpp,
             'ComputedStyleBaseConstants.h': self.generate_base_computed_style_constants,
         }
@@ skipping 20 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()