bindings: Supports inheritance of [Unforgeable] attributes as accessor-type properties.

Source/bindings/scripts/interface_dependency_resolver.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 101 matching lines @@
                 interface_info['inherited_extended_attributes'])
 
         resolved_definitions = merge_interface_dependencies(
             definitions,
             component,
             target_interface,
             interface_info['dependencies_full_paths'] +
             interface_info['dependencies_other_component_full_paths'],
             self.reader)
 
+        inherit_unforgeable_attributes(resolved_definitions, self.interfaces_info)
+
         for referenced_interface_name in interface_info['referenced_interfaces']:
             referenced_definitions = self.reader.read_idl_definitions(
                 self.interfaces_info[referenced_interface_name]['full_path'])
 
             for referenced_component in referenced_definitions:
                 if not is_valid_component_dependency(component, referenced_component):
                     raise Exception('This definitions: %s is defined in %s '
                                     'but reference interface:%s is defined '
                                     'in %s' % (definitions.idl_name,
                                                component,
@@ skipping 166 matching lines @@
         for key, value in extras.items():
             if key not in attributes:
                 attributes[key] = value
 
     for attribute in dependency_interface.attributes:
         update_attributes(attribute.extended_attributes, merged_extended_attributes)
     for constant in dependency_interface.constants:
         update_attributes(constant.extended_attributes, merged_extended_attributes)
     for operation in dependency_interface.operations:
         update_attributes(operation.extended_attributes, merged_extended_attributes)
+
+
+def inherit_unforgeable_attributes(resolved_definitions, interfaces_info):
+    """Inherits [Unforgeable] attributes and updates the arguments accordingly.
+
+    For each interface in |resolved_definitions|, collects all [Unforgeable]
+    attributes in ancestor interfaces in the same component and adds them to
+    the interface.  'referenced_interfaces' and 'cpp_includes' in
+    |interfaces_info| are updated accordingly.
+    """
+    def collect_unforgeable_attributes_in_ancestors(interface_name, component, unforgeable_attributes=None, referenced_interfaces=None, cpp_includes=None):
+        if unforgeable_attributes is None:
+            unforgeable_attributes = []
+        if referenced_interfaces is None:
+            referenced_interfaces = []
+        if cpp_includes is None:
+            cpp_includes = set()
+        if not interface_name:
+            return unforgeable_attributes, referenced_interfaces, cpp_includes
+        interface = interfaces_info[interface_name]
+        attrs = interface.get('unforgeable_attributes', {}).get(component, [])
+        unforgeable_attributes.extend(attrs)
+        referenced = [attr.idl_type.base_type for attr in attrs
+                      if attr.idl_type.base_type in
+                      interface.get('referenced_interfaces', [])]
+        referenced_interfaces.extend(referenced)
+        cpp_includes.update(interface.get('cpp_includes', {}).get(component, {}))
+        return collect_unforgeable_attributes_in_ancestors(

[bashi, 2015/07/28 00:38:47]

How about merge-and-return recursive results (unforgeable_attributes,
referenced_interfaces and cpp_includes) instead of passing them as arguments?

us, rs, cs =
collect_unforgeable_attributes_in_ancestors(interface.get('parent'), ...)
return us.extend(attrs), rs.extend(referenced),
cs.update(interface.get('cpp_includes', {}).get(component, {}))

[Yuki, 2015/07/29 08:16:24]

Done.

+            interface.get('parent'), component,
+            unforgeable_attributes, referenced_interfaces, cpp_includes)
+
+    for component, definitions in resolved_definitions.iteritems():
+        for interface_name, interface in definitions.interfaces.iteritems():

[bashi, 2015/07/28 00:38:47]

Help me understand: len(definitions.interfaces) could be greater than one here?

[Yuki, 2015/07/29 08:16:24]

For some interfaces, it's greater than one.
It seems there are interfaces that the main interface 'implements'.
{'WindowBase64': <idl_definitions.IdlInterface object at 0x7f5ed9cd83d0>,
'WindowTimers': <idl_definitions.IdlInterface object at 0x7f5ed9897c90>,
'ImageBitmapFactories': <idl_definitions.IdlInterface object at 0x7f5ed98b02d0>,
'Window': <idl_definitions.IdlInterface object at 0x7f5ed9b7e690>,
'GlobalEventHandlers': <idl_definitions.IdlInterface object at 0x7f5ed98f0050>,
'WindowEventHandlers': <idl_definitions.IdlInterface object at 0x7f5ed9cd8190>}

[bashi, 2015/07/29 09:24:33]

As chatted offline, this could be executed multiple times for right-hand
interfaces of 'implements'. It may be difficult to avoid multiple execution so
I'm fine with this if this doesn't cause unexpected inheritance. Could you check
it is safe?

[Yuki, 2015/07/29 09:32:38]

I've updated the code so that we don't add any duplicates when the loop process
the same interface multiple times.

+            interface_info = interfaces_info[interface_name]
+            inherited_unforgeable_attributes, referenced_interfaces, cpp_includes = collect_unforgeable_attributes_in_ancestors(interface_info.get('parent'), component)
+            interface.attributes.extend(inherited_unforgeable_attributes)
+            referenced_interfaces.extend(interface_info.get('referenced_interfaces', []))
+            interface_info['referenced_interfaces'] = sorted(set(referenced_interfaces))
+            cpp_includes.update(interface_info.get('cpp_includes', {}).get(component, set()))
+            if 'cpp_includes' not in interface_info:
+                interface_info['cpp_includes'] = {}
+            if component not in interface_info['cpp_includes']:
+                interface_info['cpp_includes'][component] = set()
+            interface_info['cpp_includes'][component].update(cpp_includes)