Restructure handling of list type extended attributes

Source/bindings/scripts/v8_utilities.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 40 matching lines @@
     'WOFF',
     'XML',
     'XSLT',
 ]
 
 
 ################################################################################
 # Extended attribute parsing
 ################################################################################
 
-def extended_attribute_value_contains(extended_attribute_value, value):
-    return (extended_attribute_value and
-            value in re.split('[|,]', extended_attribute_value))
+def extended_attribute_value_contains(extended_attribute_value, key):
+    return (extended_attribute_value == key or
+            (isinstance(extended_attribute_value, list) and
+             key in extended_attribute_value))
 
 
 def has_extended_attribute(definition_or_member, extended_attribute_list):
     return any(extended_attribute in definition_or_member.extended_attributes
                for extended_attribute in extended_attribute_list)
 
 
 def has_extended_attribute_value(definition_or_member, name, value):
     extended_attributes = definition_or_member.extended_attributes
     return (name in extended_attributes and
             extended_attribute_value_contains(extended_attributes[name], value))
 
 
-def sorted_extended_attribute_set(definition_or_member, name):
+def extended_attribute_value_as_list(definition_or_member, name):
     extended_attributes = definition_or_member.extended_attributes
     if name not in extended_attributes:
-        return []
-
-    attribute_values = re.split('[|,]', extended_attributes[name])
-    return sorted(attribute_values)
+        return None
+    value = extended_attributes[name]
+    if isinstance(value, list):
+        return value
+    return [value]
 
 
 ################################################################################
 # String handling
 ################################################################################
 
 def capitalize(name):
     """Capitalize first letter or initial acronym (used in setter names)."""
     for acronym in ACRONYMS:
         if name.startswith(acronym.lower()):
@@ skipping 121 matching lines @@
 DELIMITER_TO_OPERATOR = {
     '|': '||',
     ',': '&&',
 }
 
 
 def conditional_string(definition_or_member):
     extended_attributes = definition_or_member.extended_attributes
     if 'Conditional' not in extended_attributes:
         return None
-    conditional = extended_attributes['Conditional']
-    for delimiter in ',|':
-        if delimiter in conditional:
-            conditions = conditional.split(delimiter)
-            operator_separator = ' %s ' % DELIMITER_TO_OPERATOR[delimiter]
-            return operator_separator.join('ENABLE(%s)' % expression for expression in sorted(conditions))
-    return 'ENABLE(%s)' % conditional
+    return 'ENABLE(%s)' % extended_attributes['Conditional']
 
 
 # [DeprecateAs]
 def deprecate_as(member):
     extended_attributes = member.extended_attributes
     if 'DeprecateAs' not in extended_attributes:
         return None
     includes.add('core/frame/UseCounter.h')
     return extended_attributes['DeprecateAs']
 
 
 # [Exposed]
 EXPOSED_EXECUTION_CONTEXT_METHOD = {
     'DedicatedWorker': 'isDedicatedWorkerGlobalScope',
     'ServiceWorker': 'isServiceWorkerGlobalScope',
     'SharedWorker': 'isSharedWorkerGlobalScope',
     'Window': 'isDocument',
     'Worker': 'isWorkerGlobalScope',
 }
 
 
 def exposed(definition_or_member, interface):
-    exposure_set = sorted_extended_attribute_set(definition_or_member, 'Exposed')
+    exposure_set = extended_attribute_value_as_list(definition_or_member, 'Exposed')
     if not exposure_set:
         return None
 
     interface_exposure_set = expanded_exposure_set_for_interface(interface)
 
     # Methods must not be exposed to a broader scope than their interface.
     if not set(exposure_set).issubset(interface_exposure_set):
         raise ValueError('Interface members\' exposure sets must be a subset of the interface\'s.')
 
     exposure_checks = []
     for environment in exposure_set:
         # Methods must be exposed on one of the scopes known to Blink.
         if environment not in EXPOSED_EXECUTION_CONTEXT_METHOD:
             raise ValueError('Values for the [Exposed] annotation must reflect to a valid exposure scope.')
 
         exposure_checks.append('context->%s()' % EXPOSED_EXECUTION_CONTEXT_METHOD[environment])
 
     return ' || '.join(exposure_checks)
 
 
 def expanded_exposure_set_for_interface(interface):
-    exposure_set = sorted_extended_attribute_set(interface, 'Exposed')
+    exposure_set = extended_attribute_value_as_list(interface, 'Exposed')
 
     # "Worker" is an aggregation for the different kinds of workers.
     if 'Worker' in exposure_set:
         exposure_set.extend(('DedicatedWorker', 'SharedWorker', 'ServiceWorker'))
 
     return sorted(set(exposure_set))
 
 
 # [GarbageCollected], [WillBeGarbageCollected]
 def gc_type(definition):
@@ skipping 37 matching lines @@
 
     The returned function checks if a method/attribute is enabled.
     Given extended attribute RuntimeEnabled=FeatureName, return:
         RuntimeEnabledFeatures::{featureName}Enabled
     """
     extended_attributes = definition_or_member.extended_attributes
     if 'RuntimeEnabled' not in extended_attributes:
         return None
     feature_name = extended_attributes['RuntimeEnabled']
     return 'RuntimeEnabledFeatures::%sEnabled' % uncapitalize(feature_name)