Extract default naming logic in StyleBuilderWriter to a method.

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
+from collections import OrderedDict, defaultdict
 
 
 # Temporary hard-coded list of fields that are not CSS properties.
 # TODO(shend): Put this into its own JSON5 file.
 NONPROPERTIES = [
     {'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': [
@@ skipping 272 matching lines @@
     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.
-        for property_ in NONPROPERTIES:
-            property_['name_for_methods'] = property_['name']
-            if 'field_type_path' not in property_:

[Bugs Nash, 2017/04/12 23:31:45]

this field_type_path logic does not seem to be in
_apply_property_naming_defaults

[shend, 2017/04/12 23:41:03]

This line should be fine because all it's doing is setting
property_['field_type_path'] to None if it doesn't exist, which is now subsumed
by the defaultdict. In retrospect, I probably should've split this patch into
two because it's kinda doing two somewhat related things.

[Bugs Nash, 2017/04/12 23:52:37]

The default dict doesn't add field_type_path at all though correct?

[shend, 2017/04/12 23:57:28]

Yeah, it doesn't add field_type_path. So if property_ originally had
field_type_path, then it'll keep that value, but if it didn't, then it'll be
None, not a KeyError.

-                property_['field_type_path'] = None
-            if 'type_name' not in property_:
-                property_['type_name'] = 'E' + enum_type_name(property_['name_for_methods'])
+        nonproperties = [defaultdict(lambda: None, item) for item in NONPROPERTIES]
+
+        for property_ in nonproperties:
+            self._apply_property_naming_defaults(property_)
 
         property_values = self._properties.values()
 
         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]
             # CSS properties are not allowed to explicitly specify their field_size.
             property_['field_size'] = None
 
-        self._generated_enums = _create_enums(property_values + NONPROPERTIES)
+        self._generated_enums = _create_enums(property_values + nonproperties)
 
         all_fields = (_create_fields('property', property_values) +
-                      _create_fields('nonproperty', NONPROPERTIES))
+                      _create_fields('nonproperty', nonproperties))
 
         # 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(property_values + nonproperties)
 
 
     @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,
         }
@@ skipping 10 matching lines @@
     @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()