Remove the concept of 'nonproperties' from ComputedStyle generator.

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 58 matching lines @@
     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
-            - 'nonproperty': for fields that are not CSS properties
         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).
         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,
-                 field_template, field_group, size, default_value,
+                 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.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'
-        self.is_nonproperty = field_role == 'nonproperty'
-        assert (self.is_property, self.is_inherited_flag, self.is_nonproperty).count(True) == 1, \
-            'Field role has to be exactly one of: property, inherited_flag, nonproperty'
+        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.
@@ skipping 50 matching lines @@
                     ("'" + property_['name'] + "' can't have type_name '" + enum_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
 
     # Return the enums sorted by key (enum name)
     return OrderedDict(sorted(enums.items(), key=lambda t: t[0]))
 
 
-def _create_field(field_role, property_):
+def _create_property_field(property_):
     """
-    Create a property or nonproperty field.
+    Create a property field.
     """
-    assert field_role in ('property', 'nonproperty')
-
     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)))
@@ skipping 10 matching lines @@
         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
 
     return Field(
-        field_role,
+        'property',
         name_for_methods,
         property_name=property_['name'],
         inherited=property_['inherited'],
         independent=property_['independent'],
         type_name=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',
         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)),
     )
 
 
 def _create_fields(properties):
     """
-    Create ComputedStyle fields from properties or nonproperties and return a list of Field objects.
+    Create ComputedStyle fields from properties 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_))
 
-            # TODO(shend): Get rid of the property/nonproperty field roles.
-            # If the field has_custom_compare_and_copy, then it does not appear in
-            # ComputedStyle::operator== and ComputedStyle::CopyNonInheritedFromCached.
-            field_role = 'nonproperty' if property_['has_custom_compare_and_copy'] else 'property'
-            fields.append(_create_field(field_role, property_))
+            fields.append(_create_property_field(property_))
 
     return fields
 
 
 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]
@@ skipping 97 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()