IDL bindings: Avoid extended attributes leaking onto merged interface.

third_party/WebKit/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 235 matching lines @@
 
 
 def transfer_extended_attributes(dependency_interface, dependency_interface_basename):
     """Transfer extended attributes from dependency interface onto members.
 
     Merging consists of storing certain interface-level data in extended
     attributes of the *members* (because there is no separate dependency
     interface post-merging).
 
     The data storing consists of:
-    * applying certain extended attributes from the dependency interface
-      to its members
+    * moving certain extended attributes from the dependency interface
+      to its members (deleting the extended attribute from the interface)
     * storing the C++ class of the implementation in an internal
       extended attribute of each member, [PartialInterfaceImplementedAs]
 
     No return: modifies dependency_interface in place.
     """
-    merged_extended_attributes = dict(
-        (key, value)
-        for key, value in dependency_interface.extended_attributes.iteritems()
-        if key in DEPENDENCY_EXTENDED_ATTRIBUTES)
+    merged_extended_attributes = {}
+    for key in DEPENDENCY_EXTENDED_ATTRIBUTES:
+        value = dependency_interface.extended_attributes.get(key)
+        if not value:
+            continue
+
+        merged_extended_attributes[key] = value
+        # Remove the merged attributes from the original dependency interface.
+        # This ensures that if other dependency interfaces are merged onto this
+        # one, its extended_attributes do not leak through
+        # (https://crbug.com/603782).
+        del dependency_interface.extended_attributes[key]
 
     # A partial interface's members are implemented as static member functions
     # in a separate C++ class. This class name is stored in
     # [PartialInterfaceImplementedAs] which defaults to the basename of
     # dependency IDL file.
     # This class name can be overridden by [ImplementedAs] on the partial
     # interface definition.
     #
     # Note that implemented interfaces do *not* need [ImplementedAs], since
     # they are implemented on the C++ object |impl| itself, just like members of
     # the main interface definition, so the bindings do not need to know in
     # which class implemented interfaces are implemented.
     #
     # Currently [LegacyTreatAsPartialInterface] can be used to have partial
     # interface behavior on implemented interfaces, but this is being removed
     # as legacy cruft:
     # FIXME: Remove [LegacyTreatAsPartialInterface]
     # http://crbug.com/360435
     #
     # Note that [ImplementedAs] is used with different meanings on interfaces
     # and members:
     # for Blink class name and function name (or constant name), respectively.
     # Thus we do not want to copy this from the interface to the member, but
     # instead extract it and handle it separately.
     if (dependency_interface.is_partial or
         'LegacyTreatAsPartialInterface' in dependency_interface.extended_attributes):
         merged_extended_attributes['PartialInterfaceImplementedAs'] = (
-            dependency_interface.extended_attributes.get(
+            dependency_interface.extended_attributes.pop(
                 'ImplementedAs', dependency_interface_basename))
 
     def update_attributes(attributes, extras):
         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:
@@ skipping 32 matching lines @@
             # 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))
             merge_dict_recursively(interface_info,
                                    {'cpp_includes': {component: cpp_includes}})