Moved nonproperty 'unique' to be generated 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 camel_case, lower_first
+from name_utilities import camel_case, lower_first, upper_first_letter
+
+
+# Temporary hard-coded list of fields that are not CSS properties.
+# Ideally these would be specified in a .in or .json5 file.
+NONPROPERTY_FIELDS = set([
+    # Style can not be shared.
+    'unique',
+])
 
 
 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 29 matching lines @@
 
     def __init__(self, field_family, **kwargs):
         # Values common to all fields
         # Set attributes from the keyword arguments
         for attrib in Field.REQUIRED_ATTRIBUTES:
             setattr(self, attrib, kwargs.pop(attrib))
 
         # Field family: one of these must be true
         self.is_property = field_family == 'property'
         self.is_inherited_flag = field_family == 'inherited_flag'
-        assert (self.is_property, self.is_inherited_flag).count(True) == 1, \
-            'Field family has to be exactly one of: property, inherited_flag'
+        self.is_nonproperty = field_family == 'nonproperty'
+        assert (self.is_property, self.is_inherited_flag, self.is_nonproperty).count(True) == 1, \
+            'Field family has to be exactly one of: property, inherited_flag, nonproperty'
 
         if self.is_property:
             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 = kwargs.pop('is_inherited_method_name')
         elif self.is_inherited_flag:
             # Inherited flag-only fields
             pass
@@ skipping 86 matching lines @@
         storage_type_path=None,
         size=1,
         default_value='true',
         getter_method_name=field_name_suffix_lower,
         setter_method_name='set' + field_name_suffix_upper,
         initial_method_name='initial' + field_name_suffix_upper,
         resetter_method_name='reset' + field_name_suffix_upper,
     )
 
 
+def _create_nonproperty_field(field_name):
+    """
+    Create a nonproperty field from its name and return the Field object.
+    """
+    member_name = 'm_' + field_name
+    field_name_upper = upper_first_letter(field_name)
+
+    return Field(
+        'nonproperty',
+        name=member_name,
+        property_name=field_name,
+        storage_type='bool',
+        storage_type_path=None,
+        size=1,
+        default_value='false',
+        getter_method_name=field_name,
+        setter_method_name='set' + field_name_upper,
+        initial_method_name='initial' + field_name_upper,
+        resetter_method_name='reset' + field_name_upper,
+    )
+
+
 def _create_fields(properties):
     """
     Create ComputedStyle fields from CSS properties and return a list of Field objects.
     """
     fields = []
     for property_ in properties:
         # Keywords only means we generate an enum field.
         if property_['keyword_only']:
             # 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_))
 
+    for field_name in NONPROPERTY_FIELDS:
+        fields.append(_create_nonproperty_field(field_name))
+
     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.
     """
     # Since fields cannot cross word boundaries, in order to minimize
     # padding, group fields into buckets so that as many buckets as possible
@@ skipping 90 matching lines @@
     def generate_base_computed_style_constants(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
             'fields': self._fields,
             'expected_total_field_bytes': self._expected_total_field_bytes,
         }
 
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()