Support [TypeChecking] on dependent/partial interfaces.

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 26 matching lines @@
 """
 
 import os.path
 from utilities import idl_filename_to_component, is_valid_component_dependency
 
 # 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 = set([
-    'Conditional',
-    'PerContextEnabled',
-    'RuntimeEnabled',
-])
+#
+# Paired with the extended attribute name is its value type; needed to be able
+# to correctly merge interface-level occurrences with ones that may
+# be present on the method/attribute/constant.
+DEPENDENCY_EXTENDED_ATTRIBUTES = {
+    'Conditional': 'string',
+    'PerContextEnabled': 'string',
+    'RuntimeEnabled': 'string',
+    'TypeChecking': 'list',
+}
 
 
 class InterfaceDependencyResolver(object):
     def __init__(self, interfaces_info, reader):
         """Initialize dependency resolver.
 
         Args:
             interfaces_info:
                 dict of interfaces information, from compute_dependencies.py
             reader:
@@ skipping 174 matching lines @@
     * applying certain extended attributes from the dependency interface
       to its members
     * 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)
+        if key in DEPENDENCY_EXTENDED_ATTRIBUTES.keys())
 
     # 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
@@ skipping 10 matching lines @@
     # 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(
                 'ImplementedAs', dependency_interface_basename))
 
+    def update_attributes(attributes, extras):
+        def toList(x):

[bashi, 2015/02/23 01:54:11]

nit: toList() -> to_list()

[sof, 2015/02/23 06:08:55]

thanks, done.

+            if type(x) is list:
+                return x
+            else:
+                return [x]
+
+        for key, value in extras.items():
+            if key in attributes:
+                # Interface-level extended attributes do not take precedence
+                # over same attribute at the method/attribute/const-level.
+                # If the attribute value is a list, the two are combined.
+                if DEPENDENCY_EXTENDED_ATTRIBUTES[key] == 'list':
+                    attributes[key] = toList(attributes[key]) + toList(value)
+            else:
+                attributes[key] = value
+
     for attribute in dependency_interface.attributes:
-        attribute.extended_attributes.update(merged_extended_attributes)
+        update_attributes(attribute.extended_attributes, merged_extended_attributes)
     for constant in dependency_interface.constants:
-        constant.extended_attributes.update(merged_extended_attributes)
+        update_attributes(constant.extended_attributes, merged_extended_attributes)
     for operation in dependency_interface.operations:
-        operation.extended_attributes.update(merged_extended_attributes)
+        update_attributes(operation.extended_attributes, merged_extended_attributes)