Generate StyleRareInheritedData in ComputedStyleBase.

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',
-    'Font', 'FillLayer', 'NinePieceImage',  # Aligns like a void * (can be 32 or 64 bits)
-    'LengthBox', 'LengthSize', 'Length', 'float',
+    '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',
     'short',
-    'char',
+    'uint8_t', 'char',
     'bool'
 ]
 
 # TODO(shend): Improve documentation and add docstrings.
 
 
 def _flatten_list(x):
     """Flattens a list of lists into a single list."""
     return list(chain.from_iterable(x))
 
@@ skipping 60 matching lines @@
 
     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).
+        pointer_type_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,
+    def __init__(self, field_role, name_for_methods, property_name, type_name, pointer_type_name,
                  field_template, field_group, size, default_value, has_custom_compare_and_copy,
                  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.pointer_type_name = pointer_type_name
+        self.alignment_type = self.pointer_type_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.has_custom_compare_and_copy = has_custom_compare_and_copy
 
         # Field role: one of these must be true
         self.is_property = field_role == 'property'
         self.is_inherited_flag = field_role == 'inherited_flag'
@@ skipping 128 matching lines @@
     elif property_['field_template'] == 'primitive':
         type_name = property_['type_name']
         default_value = property_['default_value']
         size = 1 if type_name == 'bool' else None  # pack bools with 1 bit.
     else:
         assert property_['field_template'] in ('monotonic_flag',)
         type_name = 'bool'
         default_value = 'false'
         size = 1
 
+    if property_['pointer_type_name']:
+        assert property_['field_template'] == 'storage_only'
+        type_name = '{}<{}>'.format(property_['pointer_type_name'], type_name)
+
     return Field(
         'property',
         name_for_methods,
         property_name=property_['name'],
         inherited=property_['inherited'],
         independent=property_['independent'],
         type_name=type_name,
+        pointer_type_name=property_['pointer_type_name'],
         field_template=property_['field_template'],
         field_group=property_['field_group'],
         size=size,
         default_value=default_value,
         has_custom_compare_and_copy=property_['has_custom_compare_and_copy'],
         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',
+        pointer_type_name=None,
         field_template='primitive',
         field_group=property_['field_group'],
         size=1,
         default_value='true',
         has_custom_compare_and_copy=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)),
     )
 
@@ skipping 42 matching lines @@
         if not added_to_bucket:
             field_buckets.append([field])
 
     return _flatten_list(field_buckets)
 
 
 def _reorder_non_bit_fields(non_bit_fields):
     # A general rule of thumb is to sort members by their alignment requirement
     # (from biggest aligned to smallest).
     for field in non_bit_fields:
-        assert field.type_name in ALIGNMENT_ORDER, \
-            "Type {} has unknown alignment. Please update ALIGNMENT_ORDER to include it.".format(field.type_name)
-    return list(sorted(non_bit_fields, key=lambda f: ALIGNMENT_ORDER.index(f.type_name)))
+        assert field.alignment_type in ALIGNMENT_ORDER, \
+            "Type {} has unknown alignment. Please update ALIGNMENT_ORDER to include it.".format(field.alignment_type)
+    return list(sorted(non_bit_fields, key=lambda f: ALIGNMENT_ORDER.index(f.alignment_type)))
 
 
 def _reorder_fields(fields):
     """
     Returns a list of fields ordered to minimise padding.
     """
     # Separate out bit fields from non bit fields
     bit_fields = [field for field in fields if field.is_bit_field]
     non_bit_fields = [field for field in fields if not field.is_bit_field]
 
@@ skipping 63 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()