Generate mappings between CSSValueID and ComputedStyle enums.

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, upper_first_letter
+from name_utilities import camel_case, lower_first, upper_first_letter, enum_for_css_keyword
 
 
 # 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',
 ])
 
 
@@ skipping 102 matching lines @@
 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)  # TODO: implement for non-enums
-
-    # Separate the type path from the type name, if specified.
-    if property_['field_type_path']:
-        type_name = property_['field_type_path'].split('/')[-1]
-    else:
-        type_name = property_['type_name']
+    type_name = property_['type_name']
 
     # 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 fields, none specified '
@@ skipping 120 matching lines @@
     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,
+            'CSSValueIDMappingsGenerated.h': self.generate_css_value_mappings,
         }
 
+        property_values = self._properties.values()
+
+        # Override the type name when field_type_path is specified
+        for property_ in property_values:
+            if property_['field_type_path']:
+                property_['type_name'] = property_['field_type_path'].split('/')[-1]
+
         # Create all the enums used by properties
         self._generated_enums = _create_enums(self._properties.values())
 
         # Create all the fields
         all_fields = _create_fields(self._properties.values())
 
         # Group fields into buckets
         field_buckets = _pack_fields(all_fields)
 
         # The expected size of ComputedStyleBase is equivalent to as many words
@@ skipping 15 matching lines @@
         assert self._expected_total_field_bytes == real_total_field_bytes, \
             ('The field packing algorithm produced %s bytes, optimal is %s bytes' %
              (self._expected_total_field_bytes, real_total_field_bytes))
 
         # Order the fields so fields in each bucket are adjacent.
         self._fields = []
         for bucket in field_buckets:
             for field in bucket:
                 self._fields.append(field)
 
+        self._include_paths = _get_include_paths(self._properties.values())
+
 
     @template_expander.use_jinja('ComputedStyleBase.h.tmpl')
     def generate_base_computed_style_h(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
-            'include_paths': _get_include_paths(self._properties.values()),
+            'include_paths': self._include_paths,
             'fields': self._fields,
             'expected_total_field_bytes': self._expected_total_field_bytes,
         }
 
     @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_total_field_bytes': self._expected_total_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,
             'expected_total_field_bytes': self._expected_total_field_bytes,
         }
 
+    @template_expander.use_jinja('CSSValueIDMappingsGenerated.h.tmpl')
+    def generate_css_value_mappings(self):
+        mappings = {}
+
+        for property_ in self._properties.values():
+            if property_['field_template'] == 'keyword':
+                mappings[property_['type_name']] = {
+                    'default_value': 'k' + camel_case(property_['initial_keyword']),
+                    'mapping': [('k' + camel_case(k), enum_for_css_keyword(k)) for k in property_['keywords']],
+                }
+
+        return {
+            'include_paths': self._include_paths,
+            'mappings': mappings,
+        }
+
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()