Replace "field_type_path" with "include_paths" in CSSProperties.json5.

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 150 matching lines @@
         # If the size of the field is not None, it means it is a bit field
         self.is_bit_field = self.size is not None
 
         assert len(kwargs) == 0, 'Unexpected arguments provided to Field: ' + str(kwargs)
 
 
 def _get_include_paths(properties):
     """
     Get a list of paths that need to be included for ComputedStyleBase.
     """
-    include_paths = set()
-    for property_ in properties:
-        if property_['field_type_path'] is not None:
-            include_paths.add(property_['field_type_path'] + '.h')
-    return list(sorted(include_paths))
+    return list(sorted(set(_flatten_list(property_['include_paths'] for property_ in properties))))

[meade_UTC10, 2017/05/26 01:20:18]

uh, is there a way that the data can be structured so that this can be less
nested?

 
 
 def _group_fields(fields):
     """Groups a list of fields by their group_name and returns the root group."""
     groups = defaultdict(list)
     for field in fields:
         groups[field.group_name].append(field)
 
     no_group = groups.pop(None)
     subgroups = [Group(group_name, [], _reorder_fields(fields)) for group_name, fields in groups.items()]
@@ skipping 29 matching lines @@
                     diff_group.expressions.append(entry['method'])
     return diff_group
 
 
 def _create_enums(properties):
     """
     Returns an OrderedDict 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_type_path.
-        if property_['field_template'] == 'keyword' and property_['field_type_path'] is None:
+        # Only generate enums for keyword properties that do not require includes.
+        if property_['field_template'] == 'keyword' and len(property_['include_paths']) == 0:
             enum_name = property_['type_name']
             enum_values = [enum_value_name(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.")
 
@@ skipping 165 matching lines @@
         extra_fields = json5_generator.Json5File.load_from_files(
             [json5_file_paths[1]],
             default_parameters=self.json5_file.parameters
         ).name_dictionaries
 
         for property_ in extra_fields:
             make_style_builder.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)
 
         # Organise fields into a tree structure where the root group
         # is ComputedStyleBase.
         self._root_group = _group_fields(all_fields)
         self._diff_functions_map = _create_diff_groups_map(json5_generator.Json5File.load_from_files(
             [json5_file_paths[2]]
         ).name_dictionaries, self._root_group)
@@ skipping 16 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()