IDL Compiler: Implement CallbackInterface in database

Adds a support for callback interfaces in Web IDL database.

Bug: 839389
Change-Id: Ic4911a18fa7abf0b0891f53bc3dc8de38dd48730
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1886073
Commit-Queue: Hitoshi Yoshida <peria@chromium.org>
Reviewed-by: Yuki Shiino <yukishiino@chromium.org>
Cr-Commit-Position: refs/heads/master@{#710261}

third_party/blink/renderer/bindings/scripts/web_idl/callback_interface.py

@@ -2,13 +2,15 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import exceptions
-
 from .code_generator_info import CodeGeneratorInfo
 from .composition_parts import WithCodeGeneratorInfo
 from .composition_parts import WithComponent
 from .composition_parts import WithDebugInfo
 from .composition_parts import WithExtendedAttributes
+from .constant import Constant
+from .operation import Operation
+from .operation import OperationGroup
+
 from .ir_map import IRMap
 from .make_copy import make_copy
 from .user_defined_type import UserDefinedType
@@ -22,19 +24,39 @@ class CallbackInterface(UserDefinedType, WithExtendedAttributes,
              WithComponent, WithDebugInfo):
         def __init__(self,
                      identifier,
+                     constants=None,
+                     operations=None,
                      extended_attributes=None,
-                     code_generator_info=None,
                      component=None,
                      debug_info=None):
+            if constants is None:
+                constants = []
+            if operations is None:
+                operations = []
+            assert isinstance(constants, (list, tuple))
+            assert isinstance(operations, (list, tuple))
+            assert all(
+                isinstance(constant, Constant.IR) for constant in constants)
+            assert all(
+                isinstance(operation, Operation.IR)
+                for operation in operations)
+
             IRMap.IR.__init__(
                 self,
                 identifier=identifier,
                 kind=IRMap.IR.Kind.CALLBACK_INTERFACE)
             WithExtendedAttributes.__init__(self, extended_attributes)
-            WithCodeGeneratorInfo.__init__(self, code_generator_info)
+            WithCodeGeneratorInfo.__init__(self)
             WithComponent.__init__(self, component)
             WithDebugInfo.__init__(self, debug_info)
 
+            self.attributes = []
+            self.constants = constants
+            self.operations = operations
+            self.operation_groups = []
+            self.constructors = []
+            self.constructor_groups = []
+
     def __init__(self, ir):
         assert isinstance(ir, CallbackInterface.IR)
 
@@ -45,23 +67,35 @@ class CallbackInterface(UserDefinedType, WithExtendedAttributes,
             self, CodeGeneratorInfo(ir.code_generator_info))
         WithComponent.__init__(self, components=ir.components)
         WithDebugInfo.__init__(self, ir.debug_info)
+        self._constants = tuple([
+            Constant(constant_ir, owner=self) for constant_ir in ir.constants
+        ])
+        self._operations = tuple([
+            Operation(operation_ir, owner=self)
+            for operation_ir in ir.operations
+        ])
+        self._operation_groups = tuple([
+            OperationGroup(
+                operation_group_ir,
+                filter(lambda x: x.identifier == operation_group_ir.identifier,
+                       self._operations),
+                owner=self) for operation_group_ir in ir.operation_groups
+        ])
 
     @property
-    def operation_groups(self):
-        """
-        Returns a list of OperationGroup. Each OperationGroup may have an
-        operation or a set of overloaded operations.
-        @return tuple(OperationGroup)
-        """
-        raise exceptions.NotImplementedError()
+    def constants(self):
+        """Returns constants."""
+        return self._constants
 
     @property
-    def constants(self):
-        """
-        Returns a list of constants.
-        @return tuple(Constant)
-        """
-        raise exceptions.NotImplementedError()
+    def operations(self):
+        """Returns operations."""
+        return self._operations
+
+    @property
+    def operation_groups(self):
+        """Returns groups of overloaded operations."""
+        return self._operation_groups
 
     # UserDefinedType overrides
     @property

third_party/blink/renderer/bindings/scripts/web_idl/idl_compiler.py

@@ -277,7 +277,8 @@ class IdlCompiler(object):
             self._ir_map.add(new_interface)
 
     def _group_overloaded_functions(self):
-        old_irs = self._ir_map.irs_of_kinds(IRMap.IR.Kind.INTERFACE,
+        old_irs = self._ir_map.irs_of_kinds(IRMap.IR.Kind.CALLBACK_INTERFACE,
+                                            IRMap.IR.Kind.INTERFACE,
                                             IRMap.IR.Kind.NAMESPACE)
 
         self._ir_map.move_to_new_phase()

third_party/blink/renderer/bindings/scripts/web_idl/ir_builder.py

@@ -302,9 +302,25 @@ class _IRBuilder(object):
 
     def _build_callback_interface(self, node):
         assert node.GetProperty('CALLBACK')
-        # TODO(peria): Build members and register them in |callback_interface|
+
+        child_nodes = list(node.GetChildren())
+        extended_attributes = self._take_extended_attributes(child_nodes)
+        members = map(self._build_interface_or_namespace_member, child_nodes)
+        constants = []
+        operations = []
+        for member in members:
+            if isinstance(member, Constant.IR):
+                constants.append(member)
+            elif isinstance(member, Operation.IR):
+                operations.append(member)
+            else:
+                assert False
+
         return CallbackInterface.IR(
             identifier=Identifier(node.GetName()),
+            constants=constants,
+            operations=operations,
+            extended_attributes=extended_attributes,
             component=self._component,
             debug_info=self._build_debug_info(node))