Roll IDL to Dartium37 (r181268)

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
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Resolve interface dependencies, producing a merged IdlDefinitions object.
+
+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
+
+# 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',
+])
+
+
+class InterfaceDependencyResolver(object):
+    def __init__(self, interfaces_info, reader):
+        """Initialize dependency resolver.
+
+        Args:
+            interfaces_info:
+                dict of interfaces information, from compute_dependencies.py
+            reader:
+                IdlReader, used for reading dependency files
+        """
+        self.interfaces_info = interfaces_info
+        self.reader = reader
+
+    def resolve_dependencies(self, definitions):
+        """Resolve dependencies, merging them into IDL definitions of main file.
+
+        Dependencies consist of 'partial interface' for the same interface as
+        in the main file, and other interfaces that this interface 'implements'.
+        These are merged into the main IdlInterface, as the main IdlInterface
+        implements all these members.
+
+        Referenced interfaces are added to IdlDefinitions, but not merged into
+        the main IdlInterface, as these are only referenced (their members are
+        introspected, but not implemented in this interface).
+
+        Inherited extended attributes are also added to the main IdlInterface.
+
+        Modifies definitions in place by adding parsed dependencies.
+
+        Args:
+            definitions: IdlDefinitions object, modified in place
+        """
+        target_interface = next(definitions.interfaces.itervalues())
+        interface_name = target_interface.name
+        interface_info = self.interfaces_info[interface_name]
+
+        if 'inherited_extended_attributes' in interface_info:
+            target_interface.extended_attributes.update(
+                interface_info['inherited_extended_attributes'])
+
+        merge_interface_dependencies(definitions,
+                                     target_interface,
+                                     interface_info['dependencies_full_paths'],
+                                     self.reader)
+
+        for referenced_interface_name in interface_info['referenced_interfaces']:
+            referenced_definitions = self.reader.read_idl_definitions(
+                self.interfaces_info[referenced_interface_name]['full_path'])
+            definitions.update(referenced_definitions)
+
+
+def merge_interface_dependencies(definitions, target_interface, dependency_idl_filenames, reader):
+    """Merge dependencies ('partial interface' and 'implements') in dependency_idl_filenames into target_interface.
+
+    No return: modifies target_interface in place.
+    """
+    # Sort so order consistent, so can compare output from run to run.
+    for dependency_idl_filename in sorted(dependency_idl_filenames):
+        dependency_definitions = reader.read_idl_file(dependency_idl_filename)
+        dependency_interface = next(dependency_definitions.interfaces.itervalues())
+        dependency_interface_basename, _ = os.path.splitext(os.path.basename(dependency_idl_filename))
+
+        transfer_extended_attributes(dependency_interface,
+                                     dependency_interface_basename)
+        definitions.update(dependency_definitions)  # merges partial interfaces
+        if not dependency_interface.is_partial:
+            # Implemented interfaces (non-partial dependencies) are also merged
+            # into the target interface, so Code Generator can just iterate
+            # over one list (and not need to handle 'implements' itself).
+            target_interface.merge(dependency_interface)
+
+
+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
+    * 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)
+
+    # 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(
+                'ImplementedAs', dependency_interface_basename))
+
+    for attribute in dependency_interface.attributes:
+        attribute.extended_attributes.update(merged_extended_attributes)
+    for constant in dependency_interface.constants:
+        constant.extended_attributes.update(merged_extended_attributes)
+    for operation in dependency_interface.operations:
+        operation.extended_attributes.update(merged_extended_attributes)