Allow (non)property fields to be hardcoded in make_computed_style_base.

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,
     join_name
 )
 from collections import OrderedDict, defaultdict
 
 
-# Temporary hard-coded list of fields that are not CSS properties.
+# Temporary hard-coded list of extra fields.
 # TODO(shend): Put this into its own JSON5 file.
-NONPROPERTIES = [
+EXTRA_FIELDS = [
     {'name': 'IsLink', 'field_template': 'monotonic_flag',
      'inherited': False, 'independent': False, 'default_value': False},
     {'name': 'OriginalDisplay', 'field_template': 'keyword', 'default_value': 'inline',
      'type_name': 'EDisplay', 'inherited': False, 'independent': False,
      'keywords': [
          "inline", "block", "list-item", "inline-block", "table", "inline-table", "table-row-group", "table-header-group",
          "table-footer-group", "table-row", "table-column-group", "table-column", "table-cell", "table-caption", "-webkit-box",
          "-webkit-inline-box", "flex", "inline-flex", "grid", "inline-grid", "contents", "flow-root", "none"
      ]},
     {'name': 'InsideLink', 'field_template': 'keyword', 'default_value': 'not-inside-link',
@@ skipping 209 matching lines @@
         type_name='bool',
         field_template='primitive',
         size=1,
         default_value='true',
         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(field_role, properties):
+def _create_fields(properties):
     """
     Create ComputedStyle fields from properties or nonproperties 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_))
 
     return fields
 
 
 def _pack_fields(fields):
     """
     Group a list of fields into buckets to minimise padding.
     Returns a list of buckets, where each bucket is a list of Field objects.
     """
@@ skipping 21 matching lines @@
                 break
         if not added_to_bucket:
             field_buckets.append([field])
 
     return field_buckets
 
 
 class ComputedStyleBaseWriter(make_style_builder.StyleBuilderWriter):
     def __init__(self, json5_file_path):
         super(ComputedStyleBaseWriter, self).__init__(json5_file_path)
-        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,
-        }
-
-        # TODO(shend): Remove this once we move NONPROPERTIES to its own JSON file,
-        # since the JSON5 reader will handle missing fields and defaults.
-        nonproperties = [defaultdict(lambda: None, item) for item in NONPROPERTIES]
-
-        for property_ in nonproperties:
-            self._apply_property_naming_defaults(property_)
 
         # Ignore shorthand properties
         for property_ in self._properties.values():
             if property_['field_template'] is not None:
                 assert not property_['longhands'], \
                     "Shorthand '{}' cannot have a field_template.".format(property_['name'])
 
-        property_values = [value for value in self._properties.values() if not value['longhands']]
+        css_properties = [value for value in self._properties.values() if not value['longhands']]
 
-        for property_ in property_values:
-            # Override the type name when field_type_path is specified
-            if property_['field_type_path']:
-                property_['type_name'] = property_['field_type_path'].split('/')[-1]
+        for property_ in css_properties:
+            # All CSS properties have generated comparison and copy.
+            property_['has_custom_compare_and_copy'] = False

[alancutter (OOO until 2018), 2017/04/19 04:40:15]

# All CSS properties that are generated do not have custom comparison and copy
logic.

[shend, 2017/04/19 07:20:30]

Done.

             # CSS properties are not allowed to explicitly specify their field_size.
             property_['field_size'] = None
 
-        self._generated_enums = _create_enums(property_values + nonproperties)
+        # TODO(shend): Remove this once we move EXTRA_FIELDS to its own JSON file,
+        # since the JSON5 reader will handle missing fields and defaults.
+        extra_fields = [defaultdict(lambda: None, item) for item in EXTRA_FIELDS]
 
-        all_fields = (_create_fields('property', property_values) +
-                      _create_fields('nonproperty', nonproperties))
+        for property_ in extra_fields:
+            # TODO(shend): Remove the line below once we move EXTRA_FIELDS to its
+            # own file which would enforce defaults.
+            property_['has_custom_compare_and_copy'] = True
+            self._apply_property_naming_defaults(property_)
+
+        all_properties = css_properties + extra_fields
+
+        # Override the type name when field_type_path is specified
+        for property_ in all_properties:
+            if property_['field_type_path']:
+                property_['type_name'] = property_['field_type_path'].split('/')[-1]
+
+        self._generated_enums = _create_enums(all_properties)
+
+        all_fields = _create_fields(all_properties)
 
         # Separate the normal fields from the bit fields
         bit_fields = [field for field in all_fields if field.is_bit_field]
         normal_fields = [field for field in all_fields if not field.is_bit_field]
 
         # Pack bit fields into buckets
         field_buckets = _pack_fields(bit_fields)
 
         # The expected size of ComputedStyleBase is equivalent to as many words
         # as the total number of buckets.
@@ skipping 16 matching lines @@
              (self._expected_bit_field_bytes, real_bit_field_bytes))
 
         # Normal fields go first, then the bit fields.
         self._fields = list(normal_fields)
 
         # Order the fields so fields in each bucket are adjacent.
         for bucket in field_buckets:
             for field in bucket:
                 self._fields.append(field)
 
-        self._include_paths = _get_include_paths(property_values + nonproperties)
-
+        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,
+        }
 
     @template_expander.use_jinja('ComputedStyleBase.h.tmpl')
     def generate_base_computed_style_h(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
             'include_paths': self._include_paths,
             'fields': self._fields,
         }
 
     @template_expander.use_jinja('ComputedStyleBase.cpp.tmpl')
     def generate_base_computed_style_cpp(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
             'fields': self._fields,
             'expected_bit_field_bytes': self._expected_bit_field_bytes,
         }
 
     @template_expander.use_jinja('ComputedStyleBaseConstants.h.tmpl')
     def generate_base_computed_style_constants(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
             'fields': self._fields,
         }
 
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()