IDL: Binding code generation for dictionaries

Source/bindings/scripts/idl_types.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """IDL type handling.
 
 Classes:
 IdlTypeBase
  IdlType
  IdlUnionType
 """
@@ skipping 103 matching lines @@
 
     @property
     def is_basic_type(self):
         return False
 
     @property
     def is_callback_function(self):
         return False
 
     @property
+    def is_dictionary(self):
+        return False
+
+    @property
     def is_enum(self):
         return False
 
     @property
     def is_integer_type(self):
         return False
 
     @property
     def is_numeric_type(self):
         return False
@@ skipping 28 matching lines @@
 # IdlType
 ################################################################################
 
 class IdlType(IdlTypeBase):
     # FIXME: incorporate Nullable, etc.
     # FIXME: use nested types: IdlArrayType, IdlNullableType, IdlSequenceType
     # to support types like short?[] vs. short[]?, instead of treating these
     # as orthogonal properties (via flags).
     callback_functions = set()
     callback_interfaces = set()
+    dictionaries = set()
     enums = {}  # name -> values
 
     def __init__(self, base_type, is_array=False, is_sequence=False, is_nullable=False, is_unrestricted=False):
         super(IdlType, self).__init__(is_array=is_array, is_sequence=is_sequence, is_nullable=is_nullable)
         if is_array and is_sequence:
             raise ValueError('Array of Sequences are not allowed.')
         if is_unrestricted:
             self.base_type = 'unrestricted %s' % base_type
         else:
             self.base_type = base_type
@@ skipping 32 matching lines @@
 
     @property
     def is_callback_function(self):
         return self.base_type in IdlType.callback_functions
 
     @property
     def is_callback_interface(self):
         return self.base_type in IdlType.callback_interfaces
 
     @property
+    def is_dictionary(self):
+        return self.base_type in IdlType.dictionaries
+
+    @property
     def is_composite_type(self):
         return (self.name == 'Any' or
                 self.array_element_type or
                 self.sequence_element_type or
                 self.is_union_type)
 
     @property
     def is_enum(self):
         # FIXME: add an IdlEnumType class and a resolve_enums step at end of
         # IdlDefinitions constructor
@@ skipping 17 matching lines @@
 
     @property
     def is_interface_type(self):
         # Anything that is not another type is an interface type.
         # http://www.w3.org/TR/WebIDL/#idl-types
         # http://www.w3.org/TR/WebIDL/#idl-interface
         # In C++ these are RefPtr or PassRefPtr types.
         return not(self.is_basic_type or
                    self.is_composite_type or
                    self.is_callback_function or
+                   self.is_dictionary or
                    self.is_enum or
                    self.name == 'Object' or
                    self.name == 'Promise')  # Promise will be basic in future
 
     @property
     def is_string_type(self):
         return self.base_type_name in STRING_TYPES
 
     @property
     def may_raise_exception_on_conversion(self):
@@ skipping 26 matching lines @@
 
     @classmethod
     def set_callback_functions(cls, new_callback_functions):
         cls.callback_functions.update(new_callback_functions)
 
     @classmethod
     def set_callback_interfaces(cls, new_callback_interfaces):
         cls.callback_interfaces.update(new_callback_interfaces)
 
     @classmethod
+    def set_dictionaries(cls, new_dictionaries):
+        cls.dictionaries.update(new_dictionaries)
+
+    @classmethod
     def set_enums(cls, new_enums):
         cls.enums.update(new_enums)
 
     def resolve_typedefs(self, typedefs):
         if self.base_type not in typedefs:
             return self
         new_type = typedefs[self.base_type]
         if type(new_type) != type(self):
             # If type changes, need to return a different object,
             # since can't change type(self)
@@ skipping 28 matching lines @@
 
     @property
     def name(self):
         return 'Or'.join(member_type.name for member_type in self.member_types)
 
     def resolve_typedefs(self, typedefs):
         self.member_types = [
             typedefs.get(member_type, member_type)
             for member_type in self.member_types]
         return self