Clean up type handling in make_computed_style_base.py.

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 19 matching lines @@
                           inherited by this style or set explicitly
     """
 
     # List of required attributes for a field which need to be passed in by
     # keyword arguments
     REQUIRED_ATTRIBUTES = set([
         # Name of field
         'name',
         # Name of property field is for
         'property_name',
-        # Internal field storage type (storage_type_path can be None)
-        'storage_type',
-        'storage_type_path',
+        # Affects how the field is generated (keyword, primitive, external)

[meade_UTC10, 2017/02/13 06:46:24]

How does it affect it? What are the valid values? Do you assert somewhere that
it is one of the valid values?

Also where is this used? Is it only in the jinja templates (or is it a typo that
some things below are field_template)?

[shend, 2017/02/16 02:48:58]

Added explanations in the JSON5. Made naming consistent.

+        'template',
+        # Path to predefined class for overriding generated types.
+        'type_path',
+        # Name of the type (e.g. EClear, int)
+        'type_name',

[meade_UTC10, 2017/02/13 06:46:24]

Could you describe the relationship between these?

e.g.
"I f it's a generated enum, type_path is empty, and type_name is the enum name.
If it's a platform type, type_name is the name of the type, and type_path is the
path to the directory containing that type (relative to <someDirectory>)"

[shend, 2017/02/16 02:48:58]

Added comment to refer readers to the JSON5 file, which has a detailed
explanation already.

         # Bits needed for storage
         'size',
         # Default value for field
         'default_value',
         # Method names
         'getter_method_name',
         'setter_method_name',
         'initial_method_name',
         'resetter_method_name',
     ])
 
-    def __init__(self, field_family, **kwargs):
+    def __init__(self, role, **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'
+        # Field role: one of these must be true
+        self.is_property = role == 'property'
+        self.is_inherited_flag = role == 'inherited_flag'
         assert (self.is_property, self.is_inherited_flag).count(True) == 1, \
-            'Field family has to be exactly one of: property, inherited_flag'
+            'Field role has to be exactly one of: property, inherited_flag'
 
         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
 
         assert len(kwargs) == 0, 'Unexpected arguments provided to Field: ' + str(kwargs)
 
 
 def _create_enums(properties):
     """
     Returns a dictionary of enums to be generated, enum name -> [list of enum values]
     """
     enums = {}
     for property_ in properties:
-        # Only generate enums for keyword properties that use the default field_storage_type.
-        if property_['keyword_only'] and property_['field_storage_type'] is None:
+        # Only generate enums for keyword properties that use the default field_type_path.
+        if property_['field_template'] == 'keyword' and property_['field_type_path'] is None:
             enum_name = property_['type_name']
             # From the Blink style guide: Enum members should use InterCaps with an initial capital letter. [names-enum-members]
             enum_values = [('k' + camel_case(k)) for k in property_['keywords']]
 
             if enum_name in enums:
                 # There's an enum with the same name, check if the enum values are the same
                 assert set(enums[enum_name]) == set(enum_values), \
                     ("'" + 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 enums
 
 
 def _create_property_field(property_):
     """
     Create a property field from a CSS property and return the Field object.
     """
     property_name = property_['name_for_methods']
     property_name_lower = lower_first(property_name)
 
     # From the Blink style guide: Other data members should be prefixed by "m_". [names-data-members]
     field_name = 'm_' + property_name_lower
-    bits_needed = math.log(len(property_['keywords']), 2)
+    bits_needed = math.log(len(property_['keywords']), 2)  # TODO: implement for non-enums
 
     # Separate the type path from the type name, if specified.
-    if property_['field_storage_type']:
-        type_path = property_['field_storage_type']
+    if property_['field_type_path']:
+        type_path = property_['field_type_path']
         type_name = type_path.split('/')[-1]
     else:
+        type_path = None
         type_name = property_['type_name']
-        type_path = None
 
     # For now, the getter name should match the field name. Later, getter names
     # will start with an uppercase letter, so if they conflict with the type name,
     # add 'get' to the front.
     getter_method_name = property_name_lower
     if type_name == property_name:
         getter_method_name = 'get' + property_name
 
     assert property_['initial_keyword'] is not None, \
-        ('MakeComputedStyleBase requires an initial keyword for keyword_only values, none specified '
+        ('MakeComputedStyleBase requires an initial keyword for keyword fields, none specified '
          'for property ' + property_['name'])
     default_value = type_name + '::k' + camel_case(property_['initial_keyword'])
 
-    # Add the property itself as a member variable.
     return Field(
         'property',
         name=field_name,
         property_name=property_['name'],
         inherited=property_['inherited'],
         independent=property_['independent'],
-        storage_type=type_name,
-        storage_type_path=type_path,
+        template=property_['field_template'],
+        type_path=type_path,
+        type_name=type_name,
         size=int(math.ceil(bits_needed)),
         default_value=default_value,
         getter_method_name=getter_method_name,
         setter_method_name='set' + property_name,
         initial_method_name='initial' + property_name,
         resetter_method_name='reset' + property_name,
         is_inherited_method_name=property_name_lower + 'IsInherited',
     )
 
 
 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.
     """
     property_name = property_['name_for_methods']
     property_name_lower = lower_first(property_name)
 
     field_name_suffix_upper = property_name + 'IsInherited'
     field_name_suffix_lower = property_name_lower + 'IsInherited'
 
     return Field(
         'inherited_flag',
         name='m_' + field_name_suffix_lower,
         property_name=property_['name'],
-        storage_type='bool',
-        storage_type_path=None,
+        template='primitive',
+        type_path=None,
+        type_name='bool',
         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_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']:
+        # Only generate properties that have a field type
+        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_))
 
     return fields
 
 
@@ skipping 97 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()