Revert of Revert of Fix serialization of alias_for properties

Source/build/scripts/make_css_property_names.py

 #!/usr/bin/env python
 
 import subprocess
 import sys
 
 import css_properties
 import in_generator
 import license
 
 
@@ skipping 97 matching lines @@
 %%%%
 %(property_to_enum_map)s
 %%%%
 const Property* findProperty(register const char* str, register unsigned int len)
 {
     return %(class_name)sHash::findPropertyImpl(str, len);
 }
 
 const char* getPropertyName(CSSPropertyID id)
 {
-    if (id < firstCSSProperty)
-        return 0;
+    ASSERT(id >= firstCSSProperty && id <= lastUnresolvedCSSProperty);
     int index = id - firstCSSProperty;
-    if (index >= numCSSProperties)
-        return 0;
     return propertyNameStringsPool + propertyNameStringsOffsets[index];
 }
 
 const AtomicString& getPropertyNameAtomicString(CSSPropertyID id)
 {
-    if (id < firstCSSProperty)
-        return nullAtom;
+    ASSERT(id >= firstCSSProperty && id <= lastUnresolvedCSSProperty);
     int index = id - firstCSSProperty;
-    if (index >= numCSSProperties)
-        return nullAtom;
-
-    static AtomicString* propertyStrings = new AtomicString[numCSSProperties]; // Intentionally never destroyed.
+    static AtomicString* propertyStrings = new AtomicString[lastUnresolvedCSSProperty]; // Intentionally never destroyed.
     AtomicString& propertyString = propertyStrings[index];
     if (propertyString.isNull()) {
         const char* propertyName = propertyNameStringsPool + propertyNameStringsOffsets[index];
         propertyString = AtomicString(propertyName, strlen(propertyName), AtomicString::ConstructFromLiteral);
     }
     return propertyString;
 }
 
 String getPropertyNameString(CSSPropertyID id)
 {
@@ skipping 45 matching lines @@
             'class_name': self.class_name,
             'property_enums': "\n".join(map(self._enum_declaration, self._properties_including_aliases)),
             'first_property_id': self._first_enum_value,
             'properties_count': len(self._properties),
             'last_property_id': self._first_enum_value + len(self._properties) - 1,
             'last_unresolved_property_id': max(property["enum_value"] for property in self._properties_including_aliases),
             'max_name_length': max(map(len, self._properties)),
         }
 
     def generate_implementation(self):
+        enum_value_to_name = {property['enum_value']: property['name'] for property in self._properties_including_aliases}
         property_offsets = []
+        property_names = []
         current_offset = 0
-        for property in self._properties_including_aliases:
+        for enum_value in range(1, max(enum_value_to_name) + 1):
             property_offsets.append(current_offset)
-            current_offset += len(property["name"]) + 1
+            if enum_value in enum_value_to_name:
+                name = enum_value_to_name[enum_value]
+                property_names.append(name)
+                current_offset += len(name) + 1
 
         css_name_and_enum_pairs = [(property['name'], property['property_id']) for property in self._properties_including_aliases]
 
         gperf_input = GPERF_TEMPLATE % {
             'license': license.license_for_generated_cpp(),
             'class_name': self.class_name,
-            'property_name_strings': '\n'.join(map(lambda property: '    "%(name)s\\0"' % property, self._properties_including_aliases)),
-            'property_name_offsets': '\n'.join(map(lambda offset: '    %d,' % offset, property_offsets)),
-            'property_to_enum_map': '\n'.join(map(lambda property: '%s, %s' % property, css_name_and_enum_pairs)),
+            'property_name_strings': '\n'.join('    "%s\\0"' % name for name in property_names),
+            'property_name_offsets': '\n'.join('    %d,' % offset for offset in property_offsets),
+            'property_to_enum_map': '\n'.join('%s, %s' % property for property in css_name_and_enum_pairs),
         }
         # FIXME: If we could depend on Python 2.7, we would use subprocess.check_output
         gperf_args = [self.gperf_path, '--key-positions=*', '-P', '-n']
         gperf_args.extend(['-m', '50'])  # Pick best of 50 attempts.
         gperf_args.append('-D')  # Allow duplicate hashes -> More compact code.
         gperf = subprocess.Popen(gperf_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)
         return gperf.communicate(gperf_input)[0]
 
 
 if __name__ == "__main__":
     in_generator.Maker(CSSPropertyNamesWriter).main(sys.argv)