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 19 matching lines @@
 
 This library computes interface dependencies (partial interfaces and
 implements), reads the dependency files, and merges them to the IdlDefinitions
 for the main IDL file, producing an IdlDefinitions object representing the
 entire interface.
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler#TOC-Dependency-resolution
 """
 
 import os.path
-from utilities import idl_filename_to_component, is_valid_component_dependency
+from utilities import idl_filename_to_component, is_valid_component_dependency, merge_dict_recursively
 
 # The following extended attributes can be applied to a dependency interface,
 # and are then applied to the individual members when merging.
 # Note that this moves the extended attribute from the interface to the member,
 # which changes the semantics and yields different code than the same extended
 # attribute on the main interface.
 DEPENDENCY_EXTENDED_ATTRIBUTES = frozenset([
     'Conditional',
     'RuntimeEnabled',
     'TypeChecking',
@@ skipping 61 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):
+        if not interface_name:
+            # unforgeable_attributes, referenced_interfaces, cpp_includes
+            return [], [], set()
+        interface = interfaces_info[interface_name]
+        unforgeable_attributes, referenced_interfaces, cpp_includes = collect_unforgeable_attributes_in_ancestors(interface.get('parent'), component)
+        this_unforgeable = interface.get('unforgeable_attributes', {}).get(component, [])
+        unforgeable_attributes.extend(this_unforgeable)
+        this_referenced = [attr.idl_type.base_type for attr in this_unforgeable
+                           if attr.idl_type.base_type in
+                           interface.get('referenced_interfaces', [])]
+        referenced_interfaces.extend(this_referenced)
+        cpp_includes.update(interface.get('cpp_includes', {}).get(component, {}))
+        return unforgeable_attributes, referenced_interfaces, cpp_includes
+
+    for component, definitions in resolved_definitions.iteritems():
+        for interface_name, interface in definitions.interfaces.iteritems():
+            interface_info = interfaces_info[interface_name]
+            inherited_unforgeable_attributes, referenced_interfaces, cpp_includes = collect_unforgeable_attributes_in_ancestors(interface_info.get('parent'), component)
+            # This loop may process the same interface many times, so it's
+            # possible that we're adding the same attributes twice or more.
+            # So check if there is a duplicate.
+            for attr in inherited_unforgeable_attributes:
+                if attr not in interface.attributes:
+                    interface.attributes.append(attr)
+            referenced_interfaces.extend(interface_info.get('referenced_interfaces', []))
+            interface_info['referenced_interfaces'] = sorted(set(referenced_interfaces))

[tasak, 2015/07/29 12:56:45]

Just my perfornal preference. I would like to avoid updating interface_info
while resolving interface_dependency.

Is it possible to add a new extended attribute like
[PartialInterfaceImplementedAs]?
i.e. add UnforguableAttributeImplementedAs to attributes' extended attributes.
 

[Yuki, 2015/08/03 02:02:13]

Very good point.  It seems we may need redesign of IDL compiler, but it could be
a big work.  Let me leave this point as is and keep it in my mind, and when the
time come, let's work on the redesign.

+            merge_dict_recursively(interface_info,
+                                   {'cpp_includes': {component: cpp_includes}})