Updated to Chrome 45 (2454) moved from SVN to git.

bindings/dart/scripts/dart_types.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.
-
-"""Functions for type handling and type conversion (Blink/C++ <-> Dart:HTML).
-
-Extends IdlType and IdlUnionType with C++-specific properties, methods, and
-class methods.
-
-Spec:
-http://www.w3.org/TR/WebIDL/#es-type-mapping
-
-Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
-"""
-
-import posixpath
-from idl_types import IdlTypeBase, IdlType, IdlUnionType, TYPE_NAMES, IdlArrayOrSequenceType, IdlSequenceType
-
-import dart_attributes
-from dart_utilities import DartUtilities
-from v8_globals import includes
-
-
-################################################################################
-# CPP -specific handling of IDL types for Dart:Blink
-################################################################################
-
-NON_WRAPPER_TYPES = frozenset([
-    'Dictionary',
-    'EventHandler',
-    'EventListener',
-    'NodeFilter',
-    'SerializedScriptValue',
-])
-TYPED_ARRAYS = {
-    # (cpp_type, dart_type), used by constructor templates
-    'ArrayBuffer': (None, 'ByteBuffer'),
-    'ArrayBufferView': (None, 'ByteData'),
-    'Float32Array': ('float', 'Float32List'),
-    'Float64Array': ('double', 'Float64List'),
-    'Int8Array': ('signed char', 'Int8List'),
-    'Int16Array': ('short', 'Int16List'),
-    'Int32Array': ('int', 'Int32List'),
-    'Uint8Array': ('unsigned char', 'Uint8List'),
-    'Uint8ClampedArray': ('unsigned char', 'Uint8ClampedList'),
-    'Uint16Array': ('unsigned short', 'Uint16List'),
-    'Uint32Array': ('unsigned int', 'Uint32List'),
-}
-
-
-IdlTypeBase.is_typed_array_type = property(
-    lambda self: self.base_type in TYPED_ARRAYS)
-
-
-IdlType.is_wrapper_type = property(
-    lambda self: (self.is_interface_type and
-                  self.base_type not in NON_WRAPPER_TYPES))
-
-
-################################################################################
-# C++ types
-################################################################################
-
-CPP_TYPE_SAME_AS_IDL_TYPE = set([
-    'double',
-    'float',
-    'long long',
-    'unsigned long long',
-])
-CPP_INT_TYPES = set([
-    'byte',
-    'long',
-    'short',
-])
-CPP_UNSIGNED_TYPES = set([
-    'octet',
-    'unsigned int',
-    'unsigned long',
-    'unsigned short',
-])
-CPP_SPECIAL_CONVERSION_RULES = {
-    'Date': 'double',
-    'Dictionary': 'Dictionary',
-    'EventHandler': 'EventListener*',
-    'NodeFilter': 'RefPtrWillBeRawPtr<NodeFilter>',
-    'Promise': 'ScriptPromise',
-    'ScriptValue': 'ScriptValue',
-    # FIXME: Eliminate custom bindings for XPathNSResolver  http://crbug.com/345529
-    'XPathNSResolver': 'RefPtrWillBeRawPtr<XPathNSResolver>',
-    'boolean': 'bool',
-    'unrestricted double': 'double',
-    'unrestricted float': 'float',
-}
-
-
-def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_rvalue_type=False, used_as_variadic_argument=False, used_in_cpp_sequence=False):
-    """Returns C++ type corresponding to IDL type.
-
-    |idl_type| argument is of type IdlType, while return value is a string
-
-    Args:
-        idl_type:
-            IdlType
-        raw_type:
-            bool, True if idl_type's raw/primitive C++ type should be returned.
-        used_as_rvalue_type:
-            bool, True if the C++ type is used as an argument or the return
-            type of a method.
-        used_as_variadic_argument:
-            bool, True if the C++ type is used as a variadic argument of a method.
-        used_in_cpp_sequence:
-            bool, True if the C++ type is used as an element of a container.
-            Containers can be an array, a sequence or a dictionary.
-    """
-    extended_attributes = extended_attributes or {}
-    idl_type = idl_type.preprocessed_type
-
-    # Composite types
-    native_array_element_type = idl_type.native_array_element_type
-    if native_array_element_type:
-        vector_type = cpp_ptr_type('Vector', 'HeapVector', native_array_element_type.gc_type)
-        return cpp_template_type(vector_type, native_array_element_type.cpp_type_args(used_in_cpp_sequence=True))
-
-    # Simple types
-    base_idl_type = idl_type.base_type
-
-    if base_idl_type in CPP_TYPE_SAME_AS_IDL_TYPE:
-        return base_idl_type
-    if base_idl_type in CPP_INT_TYPES:
-        return 'int'
-    if base_idl_type in CPP_UNSIGNED_TYPES:
-        return 'unsigned'
-    if base_idl_type in CPP_SPECIAL_CONVERSION_RULES:
-        return CPP_SPECIAL_CONVERSION_RULES[base_idl_type]
-
-    if base_idl_type in NON_WRAPPER_TYPES:
-        return ('PassRefPtr<%s>' if used_as_rvalue_type else 'RefPtr<%s>') % base_idl_type
-    if base_idl_type in ('DOMString', 'ByteString', 'ScalarValueString'):
-        if not raw_type:
-            return 'String'
-        return 'DartStringAdapter'
-
-    if idl_type.is_typed_array_type and raw_type:
-        return 'RefPtr<%s>' % base_idl_type
-    if idl_type.is_interface_type:
-        implemented_as_class = idl_type.implemented_as
-        if raw_type:
-            return implemented_as_class + '*'
-        new_type = 'Member' if used_in_cpp_sequence else 'RawPtr'
-        ptr_type = cpp_ptr_type(('PassRefPtr' if used_as_rvalue_type else 'RefPtr'), new_type, idl_type.gc_type)
-        return cpp_template_type(ptr_type, implemented_as_class)
-
-    # Default, assume native type is a pointer with same type name as idl type
-
-    # FIXME: How to handle sequence<WebGLShader>?
-    if base_idl_type is None:
-        base_idl_type = idl_type.inner_type.element_type.base_type
-
-    return base_idl_type + '*'
-
-
-def cpp_type_union(idl_type, extended_attributes=None, used_as_rvalue_type=False, will_be_in_heap_object=False):
-    return (member_type.cpp_type for member_type in idl_type.member_types)
-
-
-# Allow access as idl_type.cpp_type if no arguments
-IdlTypeBase.cpp_type = property(cpp_type)
-IdlTypeBase.cpp_type_args = cpp_type
-IdlUnionType.cpp_type = property(cpp_type_union)
-IdlUnionType.cpp_type_args = cpp_type_union
-
-
-IdlTypeBase.native_array_element_type = None
-IdlArrayOrSequenceType.native_array_element_type = property(
-    lambda self: self.element_type)
-
-IdlTypeBase.enum_validation_expression = property(DartUtilities.enum_validation_expression)
-
-
-def cpp_template_type(template, inner_type):
-    """Returns C++ template specialized to type, with space added if needed."""
-    if inner_type.endswith('>'):
-        format_string = '{template}<{inner_type} >'
-    else:
-        format_string = '{template}<{inner_type}>'
-    return format_string.format(template=template, inner_type=inner_type)
-
-
-def cpp_ptr_type(old_type, new_type, gc_type):
-    if gc_type == 'GarbageCollectedObject':
-        return new_type
-    if gc_type == 'WillBeGarbageCollectedObject':
-        if old_type == 'Vector':
-            return 'WillBe' + new_type
-        return old_type + 'WillBe' + new_type
-    return old_type
-
-
-def v8_type(interface_name):
-    return 'V8' + interface_name
-
-
-def dart_type(interface_name):
-    return 'Dart' + str(interface_name)
-
-
-# [ImplementedAs]
-# This handles [ImplementedAs] on interface types, not [ImplementedAs] in the
-# interface being generated. e.g., given:
-#   Foo.idl: interface Foo {attribute Bar bar};
-#   Bar.idl: [ImplementedAs=Zork] interface Bar {};
-# when generating bindings for Foo, the [ImplementedAs] on Bar is needed.
-# This data is external to Foo.idl, and hence computed as global information in
-# compute_interfaces_info.py to avoid having to parse IDLs of all used interfaces.
-IdlType.implemented_as_interfaces = {}
-
-
-def implemented_as(idl_type):
-    base_idl_type = idl_type.base_type
-    if base_idl_type in IdlType.implemented_as_interfaces:
-        return IdlType.implemented_as_interfaces[base_idl_type]
-    return base_idl_type
-
-
-IdlType.implemented_as = property(implemented_as)
-
-IdlType.set_implemented_as_interfaces = classmethod(
-    lambda cls, new_implemented_as_interfaces:
-        cls.implemented_as_interfaces.update(new_implemented_as_interfaces))
-
-
-# [GarbageCollected]
-IdlType.garbage_collected_types = set()
-
-IdlTypeBase.is_garbage_collected = False
-IdlType.is_garbage_collected = property(
-    lambda self: self.base_type in IdlType.garbage_collected_types)
-
-IdlType.set_garbage_collected_types = classmethod(
-    lambda cls, new_garbage_collected_types:
-        cls.garbage_collected_types.update(new_garbage_collected_types))
-
-
-# [WillBeGarbageCollected]
-IdlType.will_be_garbage_collected_types = set()
-
-IdlTypeBase.is_will_be_garbage_collected = False
-IdlType.is_will_be_garbage_collected = property(
-    lambda self: self.base_type in IdlType.will_be_garbage_collected_types)
-
-IdlType.set_will_be_garbage_collected_types = classmethod(
-    lambda cls, new_will_be_garbage_collected_types:
-        cls.will_be_garbage_collected_types.update(new_will_be_garbage_collected_types))
-
-
-def gc_type(idl_type):
-    if idl_type.is_garbage_collected:
-        return 'GarbageCollectedObject'
-    if idl_type.is_will_be_garbage_collected:
-        return 'WillBeGarbageCollectedObject'
-    return 'RefCountedObject'
-
-IdlTypeBase.gc_type = property(gc_type)
-
-
-################################################################################
-# Includes
-################################################################################
-
-def includes_for_cpp_class(class_name, relative_dir_posix):
-    return set([posixpath.join('bindings', relative_dir_posix, class_name + '.h')])
-
-# TODO(terry): Will we need this group header for dart:blink?
-INCLUDES_FOR_TYPE = {
-    'object': set(),
-    'Dictionary': set(['bindings/core/v8/Dictionary.h']),
-    'EventHandler': set(),
-    'EventListener': set(),
-    'HTMLCollection': set(['bindings/core/dart/DartHTMLCollection.h',
-                           'core/dom/ClassCollection.h',
-                           'core/dom/TagCollection.h',
-                           'core/html/HTMLCollection.h',
-                           'core/html/HTMLDataListOptionsCollection.h',
-                           'core/html/HTMLFormControlsCollection.h',
-                           'core/html/HTMLTableRowsCollection.h']),
-    'NodeList': set(['bindings/core/dart/DartNodeList.h',
-                     'core/dom/NameNodeList.h',
-                     'core/dom/NodeList.h',
-                     'core/dom/StaticNodeList.h',
-                     'core/html/LabelsNodeList.h']),
-    'Promise': set(['bindings/core/dart/DartScriptPromise.h']),
-    'SerializedScriptValue': set(),
-    'ScriptValue': set(['bindings/core/dart/DartScriptValue.h']),
-}
-
-
-def includes_for_type(idl_type):
-    idl_type = idl_type.preprocessed_type
-
-    # Composite types
-    if idl_type.native_array_element_type:
-        return includes_for_type(idl_type)
-
-    # Simple types
-    base_idl_type = idl_type.base_type
-    if base_idl_type in INCLUDES_FOR_TYPE:
-        return INCLUDES_FOR_TYPE[base_idl_type]
-    if idl_type.is_basic_type:
-        return set()
-    if idl_type.is_typed_array_type:
-        # Typed array factory methods are already provided by DartUtilities.h.
-        return set([])
-    if base_idl_type.endswith('ConstructorConstructor'):
-        # FIXME: rename to NamedConstructor
-        # FIXME: replace with a [NamedConstructorAttribute] extended attribute
-        # Ending with 'ConstructorConstructor' indicates a named constructor,
-        # and these do not have header files, as they are part of the generated
-        # bindings for the interface
-        return set()
-    if base_idl_type.endswith('Constructor'):
-        # FIXME: replace with a [ConstructorAttribute] extended attribute
-        base_idl_type = idl_type.constructor_type_name
-    if base_idl_type not in component_dir:
-        return set()
-    return set(['bindings/%s/dart/Dart%s.h' % (component_dir[base_idl_type],
-                                               base_idl_type)])
-
-IdlType.includes_for_type = property(includes_for_type)
-IdlUnionType.includes_for_type = property(
-    lambda self: set.union(*[includes_for_type(member_type)
-                             for member_type in self.member_types]))
-
-
-def add_includes_for_type(idl_type):
-    includes.update(idl_type.includes_for_type)
-
-IdlTypeBase.add_includes_for_type = add_includes_for_type
-IdlUnionType.add_includes_for_type = add_includes_for_type
-
-
-def includes_for_interface(interface_name):
-    return IdlType(interface_name).includes_for_type
-
-
-def add_includes_for_interface(interface_name):
-    includes.update(includes_for_interface(interface_name))
-
-
-component_dir = {}
-
-
-def set_component_dirs(new_component_dirs):
-    component_dir.update(new_component_dirs)
-
-
-################################################################################
-# Dart -> C++
-################################################################################
-
-# TODO(terry): Need to fix to handle getter/setters for onEvent.
-DART_FIX_ME = 'DART_UNIMPLEMENTED(/* Conversion unimplemented*/);'
-
-# For a given IDL type, the DartHandle to C++ conversion.
-DART_TO_CPP_VALUE = {
-    # Basic
-    'Date': 'DartUtilities::dartToDate(args, {index}, exception)',
-    'DOMString': 'DartUtilities::dartToString{null_check}(args, {index}, exception, {auto_scope})',
-    'ByteString': 'DartUtilities::dartToByteString{null_check}(args, {index}, exception, {auto_scope})',
-    'ScalarValueString': 'DartUtilities::dartToScalarValueString{null_check}(args, {index}, exception, {auto_scope})',
-    'boolean': 'DartUtilities::dartToBool{null_check}(args, {index}, exception)',
-    'float': 'static_cast<float>(DartUtilities::dartToDouble(args, {index}, exception))',
-    'unrestricted float': 'static_cast<float>(DartUtilities::dartToDouble(args, {index}, exception))',
-    'double': 'DartUtilities::dartToDouble(args, {index}, exception)',
-    'unrestricted double': 'DartUtilities::dartToDouble(args, {index}, exception)',
-    # FIXME(vsm): Inconsistent with V8.
-    'byte': 'DartUtilities::dartToUnsigned(args, {index}, exception)',
-    'octet': 'DartUtilities::dartToUnsigned(args, {index}, exception)',
-    'short': 'DartUtilities::dartToInt(args, {index}, exception)',
-    'unsigned short': 'DartUtilities::dartToUnsigned(args, {index}, exception)',
-    'long': 'DartUtilities::dartToInt(args, {index}, exception)',
-    'unsigned long': 'DartUtilities::dartToUnsignedLongLong(args, {index}, exception)',
-    'long long': 'DartUtilities::dartToLongLong(args, {index}, exception)',
-    'unsigned long long': 'DartUtilities::dartToUnsignedLongLong(args, {index}, exception)',
-    # Interface types
-    'Dictionary': 'DartUtilities::dartToDictionary{null_check}(args, {index}, exception)',
-    'EventTarget': '0 /* FIXME, DART_TO_CPP_VALUE[EventTarget] */',
-    'NodeFilter': 'nullptr /* FIXME, DART_TO_CPP_VALUE[NodeFilter] */',
-    'Promise': 'DartUtilities::dartToScriptPromise{null_check}(args, {index})',
-    'SerializedScriptValue': 'nullptr /* FIXME, DART_TO_CPP_VALUE[SerializedScriptValue] */',
-    'ScriptValue': 'DartUtilities::dartToScriptValue{null_check}(args, {index})',
-    # FIXME(vsm): Why don't we have an entry for Window? V8 does.
-    # I think I removed this as the Window object is more special in V8 - it's the
-    # global context as well.  Do we need to special case it?
-    'XPathNSResolver': 'nullptr /* FIXME, DART_TO_CPP_VALUE[XPathNSResolver] */',
-    # FIXME(vsm): This is an enum type (defined in StorageQuota.idl).
-    # We should handle it automatically, but map to a String for now.
-    'StorageType': 'DartUtilities::dartToString(args, {index}, exception, {auto_scope})',
-}
-
-
-def dart_dictionary_value_argument(idl_type, index):
-    if idl_type.is_dictionary:
-        argument_expression_format = 'DartUtilities::dartToDictionaryWithNullCheck(args, {index}, exception)'
-        return argument_expression_format.format(index=index)
-
-    return None
-
-
-def dart_dictionary_to_local_cpp_value(idl_type, index=None):
-    """Returns an expression that converts a Dictionary value as a local value."""
-    idl_type = idl_type.preprocessed_type
-
-    cpp_value = dart_dictionary_value_argument(idl_type, index)
-
-    return cpp_value
-
-IdlTypeBase.dart_dictionary_to_local_cpp_value = dart_dictionary_to_local_cpp_value
-
-
-def dart_value_to_cpp_value(idl_type, extended_attributes, variable_name,
-                            null_check, has_type_checking_interface,
-                            index, auto_scope=True):
-    # Composite types
-    native_array_element_type = idl_type.native_array_element_type
-    if native_array_element_type:
-        return dart_value_to_cpp_value_array_or_sequence(native_array_element_type, variable_name, index)
-
-    # Simple types
-    idl_type = idl_type.preprocessed_type
-    add_includes_for_type(idl_type)
-    base_idl_type = idl_type.base_type
-
-    if 'EnforceRange' in extended_attributes:
-        arguments = ', '.join([variable_name, 'EnforceRange', 'exceptionState'])
-    elif idl_type.is_integer_type:  # NormalConversion
-        arguments = ', '.join([variable_name, 'es'])
-    else:
-        arguments = variable_name
-
-    if base_idl_type in DART_TO_CPP_VALUE:
-        cpp_expression_format = DART_TO_CPP_VALUE[base_idl_type]
-    elif idl_type.is_typed_array_type:
-        # FIXME(vsm): V8 generates a type check here as well. Do we need one?
-        # FIXME(vsm): When do we call the externalized version? E.g., see
-        # bindings/dart/custom/DartWaveShaperNodeCustom.cpp - it calls
-        # DartUtilities::dartToExternalizedArrayBufferView instead.
-        # V8 always converts null here
-        cpp_expression_format = ('DartUtilities::dartTo{idl_type}WithNullCheck(args, {index}, exception)')
-    elif idl_type.is_callback_interface:
-        cpp_expression_format = ('Dart{idl_type}::create{null_check}(args, {index}, exception)')
-    elif idl_type.is_dictionary:
-        # Value of dictionary is defined in method dart_dictionary_value_argument.
-        cpp_expression_format = 'Dart{idl_type}::toImpl(dictionary, es)'
-    else:
-        cpp_expression_format = ('Dart{idl_type}::toNative{null_check}(args, {index}, exception)')
-
-    # We allow the calling context to force a null check to handle
-    # some cases that require calling context info.  V8 handles all
-    # of this differently, and we may wish to reconsider this approach
-    check_string = ''
-    if null_check or allow_null(idl_type, extended_attributes,
-                                has_type_checking_interface):
-        check_string = 'WithNullCheck'
-    elif allow_empty(idl_type, extended_attributes):
-        check_string = 'WithEmptyCheck'
-    return cpp_expression_format.format(null_check=check_string,
-                                        arguments=arguments,
-                                        index=index,
-                                        idl_type=base_idl_type,
-                                        auto_scope=DartUtilities.bool_to_cpp(auto_scope))
-
-
-def dart_value_to_cpp_value_array_or_sequence(native_array_element_type, variable_name, index):
-    # Index is None for setters, index (starting at 0) for method arguments,
-    # and is used to provide a human-readable exception message
-    if index is None:
-        index = 0  # special case, meaning "setter"
-#    else:
-#        index += 1  # human-readable index
-    if (native_array_element_type.is_interface_type and
-        native_array_element_type.name != 'Dictionary'):
-        this_cpp_type = None
-        ref_ptr_type = cpp_ptr_type('RefPtr', 'Member', native_array_element_type.gc_type)
-        # FIXME(vsm): We're not using ref_ptr_type....
-        expression_format = 'DartUtilities::toNativeVector<{native_array_element_type} >(args, {index}, {variable_name}, exception)'
-        add_includes_for_type(native_array_element_type)
-    else:
-        ref_ptr_type = None
-        this_cpp_type = native_array_element_type.cpp_type
-        expression_format = 'DartUtilities::toNativeVector<{cpp_type}>(args, {index}, {variable_name}, exception)'
-
-    expression = expression_format.format(native_array_element_type=native_array_element_type.name,
-                                          cpp_type=this_cpp_type, index=index, ref_ptr_type=ref_ptr_type,
-                                          variable_name=variable_name)
-    return expression
-
-
-def dart_value_to_local_cpp_value(idl_type, extended_attributes, variable_name,
-                                  null_check, has_type_checking_interface,
-                                  index=None, auto_scope=True):
-    """Returns an expression that converts a Dart value to a C++ value as a local value."""
-    idl_type = idl_type.preprocessed_type
-
-    cpp_value = dart_value_to_cpp_value(
-        idl_type, extended_attributes, variable_name,
-        null_check, has_type_checking_interface,
-        index, auto_scope)
-
-    return cpp_value
-
-IdlTypeBase.dart_value_to_local_cpp_value = dart_value_to_local_cpp_value
-#IdlUnionType.dart_value_to_local_cpp_value = dart_value_to_local_cpp_value
-
-
-# Insure that we don't use C++ reserved names.  Today on default is a problem.
-def check_reserved_name(name):
-    return 'default_value' if (name == 'default') else name
-
-
-################################################################################
-# C++ -> V8
-################################################################################
-
-def preprocess_idl_type(idl_type):
-    if idl_type.is_enum:
-        # Enumerations are internally DOMStrings
-        return IdlType('DOMString')
-    if (idl_type.name == 'Any' or idl_type.is_callback_function):
-        return IdlType('ScriptValue')
-    return idl_type
-
-IdlTypeBase.preprocessed_type = property(preprocess_idl_type)
-IdlUnionType.preprocessed_type = property(preprocess_idl_type)
-
-
-def preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes):
-    """Returns IDL type and value, with preliminary type conversions applied."""
-    idl_type = idl_type.preprocessed_type
-    if idl_type.name == 'Promise':
-        idl_type = IdlType('ScriptPromise')
-
-    # FIXME(vsm): V8 maps 'long long' and 'unsigned long long' to double
-    # as they are not representable in ECMAScript.  Should we do the same?
-
-    # HTML5 says that unsigned reflected attributes should be in the range
-    # [0, 2^31). When a value isn't in this range, a default value (or 0)
-    # should be returned instead.
-    extended_attributes = extended_attributes or {}
-    if ('Reflect' in extended_attributes and
-        idl_type.base_type in ['unsigned long', 'unsigned short']):
-        cpp_value = cpp_value.replace('getUnsignedIntegralAttribute',
-                                      'getIntegralAttribute')
-        cpp_value = 'std::max(0, %s)' % cpp_value
-    return idl_type, cpp_value
-
-
-def dart_conversion_type(idl_type, extended_attributes):
-    """Returns Dart conversion type, adding any additional includes.
-
-    The Dart conversion type is used to select the C++ -> Dart conversion function
-    or setDart*ReturnValue function; it can be an idl_type, a cpp_type, or a
-    separate name for the type of conversion (e.g., 'DOMWrapper').
-    """
-    extended_attributes = extended_attributes or {}
-
-    # Composite types
-    native_array_element_type = idl_type.native_array_element_type
-
-    # FIXME: Work around sequence behaving like an array.
-    if (not native_array_element_type) and type(idl_type.inner_type) is IdlSequenceType:
-        native_array_element_type = idl_type.inner_type.native_array_element_type
-
-    if native_array_element_type:
-        if native_array_element_type.is_interface_type:
-            add_includes_for_type(native_array_element_type)
-        return 'array'
-
-    # Simple types
-    base_idl_type = idl_type.base_type
-    # Basic types, without additional includes
-    if base_idl_type in CPP_INT_TYPES or base_idl_type == 'long long':
-        return 'int'
-    if base_idl_type in CPP_UNSIGNED_TYPES or base_idl_type == 'unsigned long long':
-        return 'unsigned'
-    if idl_type.is_string_type:
-        if idl_type.is_nullable:
-            return 'StringOrNull'
-        if 'TreatReturnedNullStringAs' not in extended_attributes:
-            return 'DOMString'
-        treat_returned_null_string_as = extended_attributes['TreatReturnedNullStringAs']
-        if treat_returned_null_string_as == 'Null':
-            return 'StringOrNull'
-        if treat_returned_null_string_as == 'Undefined':
-            return 'StringOrUndefined'
-        raise 'Unrecognized TreatReturnNullStringAs value: "%s"' % treat_returned_null_string_as
-    if idl_type.is_basic_type or base_idl_type == 'ScriptValue':
-        return base_idl_type
-
-    # Data type with potential additional includes
-    add_includes_for_type(idl_type)
-    if base_idl_type in DART_SET_RETURN_VALUE:  # Special dartSetReturnValue treatment
-        return base_idl_type
-
-    # Typed arrays don't have special Dart* classes for Dart.
-    if idl_type.is_typed_array_type:
-        if base_idl_type == 'ArrayBuffer':
-            return 'ArrayBuffer'
-        else:
-            return 'TypedList'
-
-    # Pointer type
-    return 'DOMWrapper'
-
-IdlTypeBase.dart_conversion_type = dart_conversion_type
-
-
-DART_SET_RETURN_VALUE = {
-    'boolean': 'Dart_SetBooleanReturnValue(args, {cpp_value})',
-    'int': 'DartUtilities::setDartIntegerReturnValue(args, {cpp_value})',
-    'unsigned': 'DartUtilities::setDartUnsignedLongLongReturnValue(args, {cpp_value})',
-    'DOMString': 'DartUtilities::setDartStringReturnValue(args, {cpp_value}, {auto_scope})',
-    # FIXME(terry): Need to handle checking to byte values > 255 throwing exception.
-    'ByteString': 'DartUtilities::setDartByteStringReturnValue(args, {cpp_value}, {auto_scope})',
-    # FIXME(terry):  Need to make valid unicode; match UTF-16 to U+FFFD REPLACEMENT CHARACTER.
-    'ScalarValueString': 'DartUtilities::setDartScalarValueStringReturnValue(args, {cpp_value}, {auto_scope})',
-    # [TreatNullReturnValueAs]
-    'StringOrNull': 'DartUtilities::setDartStringReturnValueWithNullCheck(args, {cpp_value}, {auto_scope})',
-    # FIXME(vsm): How should we handle undefined?
-    'StringOrUndefined': 'DartUtilities::setDartStringReturnValue(args, {cpp_value}, {auto_scope})',
-    'void': '',
-    # We specialize these as well in Dart.
-    'float': 'Dart_SetDoubleReturnValue(args, {cpp_value})',
-    'unrestricted float': 'Dart_SetDoubleReturnValue(args, {cpp_value})',
-    'double': 'Dart_SetDoubleReturnValue(args, {cpp_value})',
-    'unrestricted double': 'Dart_SetDoubleReturnValue(args, {cpp_value})',
-    # No special function, but instead convert value to Dart_Handle
-    # and then use general Dart_SetReturnValue.
-    'array': 'Dart_SetReturnValue(args, {cpp_value})',
-    'Date': 'Dart_SetReturnValue(args, {cpp_value})',
-    'EventHandler': DART_FIX_ME,
-    'ScriptPromise': 'Dart_SetReturnValue(args, {cpp_value})',
-    'ScriptValue': 'Dart_SetReturnValue(args, {cpp_value})',
-    'SerializedScriptValue': DART_FIX_ME,
-    # DOMWrapper
-    # TODO(terry): Remove ForMainWorld stuff.
-    'DOMWrapperForMainWorld': DART_FIX_ME,
-    # FIXME(vsm): V8 has a fast path. Do we?
-    'DOMWrapperFast': 'Dart{type_name}::returnToDart(args, WTF::getPtr({cpp_value}), {auto_scope})',
-    'DOMWrapperDefault': 'Dart{type_name}::returnToDart(args, {cpp_value}, {auto_scope})',
-    # Typed arrays don't have special Dart* classes for Dart.
-    'ArrayBuffer': 'Dart_SetReturnValue(args, DartUtilities::arrayBufferToDart({cpp_value}))',
-    'TypedList': 'Dart_SetReturnValue(args, DartUtilities::arrayBufferViewToDart({cpp_value}))',
-    'Dictionary': DART_FIX_ME,
-}
-
-
-def dart_set_return_value(idl_type, cpp_value,
-                          extended_attributes=None, script_wrappable='',
-                          release=False, for_main_world=False,
-                          auto_scope=True):
-    """Returns a statement that converts a C++ value to a Dart value and sets it as a return value.
-
-    """
-    def dom_wrapper_conversion_type():
-        if not script_wrappable:
-            return 'DOMWrapperDefault'
-        if for_main_world:
-            return 'DOMWrapperForMainWorld'
-        return 'DOMWrapperFast'
-
-    idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes)
-    this_dart_conversion_type = idl_type.dart_conversion_type(extended_attributes)
-    # SetReturn-specific overrides
-    if this_dart_conversion_type in ['Date', 'EventHandler', 'ScriptPromise', 'ScriptValue', 'SerializedScriptValue', 'array']:
-        # Convert value to Dart and then use general Dart_SetReturnValue
-        # FIXME(vsm): Why do we differ from V8 here? It doesn't have a
-        # creation_context.
-        creation_context = ''
-        if this_dart_conversion_type == 'array':
-            # FIXME: This is not right if the base type is a primitive, DOMString, etc.
-            # What is the right check for base type?
-            base_type = str(idl_type.element_type)
-            if base_type not in DART_TO_CPP_VALUE:
-                if base_type == 'None':
-                    raise Exception('Unknown base type for ' + str(idl_type))
-                creation_context = '<Dart%s>' % base_type
-            if idl_type.is_nullable:
-                creation_context = 'Nullable' + creation_context
-
-        cpp_value = idl_type.cpp_value_to_dart_value(cpp_value, creation_context=creation_context,
-                                                     extended_attributes=extended_attributes)
-    if this_dart_conversion_type == 'DOMWrapper':
-        this_dart_conversion_type = dom_wrapper_conversion_type()
-
-    format_string = DART_SET_RETURN_VALUE[this_dart_conversion_type]
-
-    if release:
-        cpp_value = '%s.release()' % cpp_value
-    statement = format_string.format(cpp_value=cpp_value,
-                                     type_name=idl_type.name,
-                                     script_wrappable=script_wrappable,
-                                     auto_scope=DartUtilities.bool_to_cpp(auto_scope))
-    return statement
-
-
-def dart_set_return_value_union(idl_type, cpp_value, extended_attributes=None,
-                              script_wrappable='', release=False, for_main_world=False,
-                              auto_scope=True):
-    """
-    release: can be either False (False for all member types) or
-             a sequence (list or tuple) of booleans (if specified individually).
-    """
-    return [
-        # FIXME(vsm): Why do we use 'result' instead of cpp_value as V8?
-        member_type.dart_set_return_value('result' + str(i),
-                                        extended_attributes,
-                                        script_wrappable,
-                                        release and release[i],
-                                        for_main_world,
-                                        auto_scope)
-            for i, member_type in
-            enumerate(idl_type.member_types)]
-
-IdlTypeBase.dart_set_return_value = dart_set_return_value
-IdlUnionType.dart_set_return_value = dart_set_return_value_union
-
-IdlType.release = property(lambda self: self.is_interface_type)
-IdlUnionType.release = property(
-    lambda self: [member_type.is_interface_type
-                  for member_type in self.member_types])
-
-
-CPP_VALUE_TO_DART_VALUE = {
-    # Built-in types
-    # FIXME(vsm): V8 uses DateOrNull - do we need a null check?
-    'Date': 'DartUtilities::dateToDart({cpp_value})',
-    'DOMString': 'DartUtilities::stringToDartString({cpp_value})',
-    'boolean': 'DartUtilities::boolToDart({cpp_value})',
-    'int': 'DartUtilities::intToDart({cpp_value})',
-    'unsigned': 'DartUtilities::unsignedLongLongToDart({cpp_value})',
-    'float': 'DartUtilities::doubleToDart({cpp_value})',
-    'unrestricted float': 'DartUtilities::doubleToDart({cpp_value})',
-    'double': 'DartUtilities::doubleToDart({cpp_value})',
-    'unrestricted double': 'DartUtilities::doubleToDart({cpp_value})',
-    # FIXME(vsm): Dart_Null?
-    'void': '',
-    # Special cases
-    'EventHandler': '-----OOPS TO DART-EVENT---',
-    # We need to generate the NullCheck version in some cases.
-    'ScriptPromise': 'DartUtilities::scriptPromiseToDart({cpp_value})',
-    'ScriptValue': 'DartUtilities::scriptValueToDart({cpp_value})',
-    'SerializedScriptValue': 'DartUtilities::serializedScriptValueToDart({cpp_value})',
-    # General
-    'array': 'DartDOMWrapper::vectorToDart{creation_context}({cpp_value})',
-    'DOMWrapper': 'Dart{idl_type}::toDart({cpp_value})',
-}
-
-
-def cpp_value_to_dart_value(idl_type, cpp_value, creation_context='', extended_attributes=None):
-    """Returns an expression that converts a C++ value to a Dart value."""
-    # the isolate parameter is needed for callback interfaces
-    idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes)
-    this_dart_conversion_type = idl_type.dart_conversion_type(extended_attributes)
-    format_string = CPP_VALUE_TO_DART_VALUE[this_dart_conversion_type]
-    statement = format_string.format(
-        cpp_value=cpp_value, creation_context=creation_context,
-        idl_type=idl_type.base_type)
-    return statement
-
-IdlTypeBase.cpp_value_to_dart_value = cpp_value_to_dart_value
-
-# FIXME(leafp) This is horrible, we should do better, but currently this is hard to do
-# in a nice way.  Best solution might be to extend DartStringAdapter to accomodate
-# initialization from constant strings, but better to do that once we're stable
-# on the bots so we can track any performance regression
-CPP_LITERAL_TO_DART_VALUE = {
-    'DOMString': {'nullptr': 'DartStringAdapter(DartStringPeer::nullString())',
-                  'String("")': 'DartStringAdapter(DartStringPeer::emptyString())',
-                  '*': 'DartUtilities::dartToString(DartUtilities::stringToDart({cpp_literal}), exception)'},
-    'ScalarValueString': {'nullptr': 'DartStringAdapter(DartStringPeer::nullString())',
-                          'String("")': 'DartStringAdapter(DartStringPeer::emptyString())',
-                          '*': 'DartUtilities::dartToScalarValueString(DartUtilities::stringToDart({cpp_literal}), exception)'},
-}
-
-
-def literal_cpp_value(idl_type, idl_literal):
-    """Converts an expression that is a valid C++ literal for this type."""
-    # FIXME: add validation that idl_type and idl_literal are compatible
-    literal_value = str(idl_literal)
-    base_type = idl_type.preprocessed_type.base_type
-    if base_type in CPP_UNSIGNED_TYPES:
-        return literal_value + 'u'
-    if base_type in CPP_LITERAL_TO_DART_VALUE:
-        if literal_value in CPP_LITERAL_TO_DART_VALUE[base_type]:
-            format_string = CPP_LITERAL_TO_DART_VALUE[base_type][literal_value]
-        else:
-            format_string = CPP_LITERAL_TO_DART_VALUE[base_type]['*']
-        return format_string.format(cpp_literal=literal_value)
-    return literal_value
-
-IdlType.literal_cpp_value = literal_cpp_value
-
-
-CPP_DEFAULT_VALUE_FOR_CPP_TYPE = {
-    'DOMString': 'DartStringAdapter(DartStringPeer::emptyString())',
-    'ByteString': 'DartStringAdapter(DartStringPeer::emptyString())',
-    'ScalarValueString': 'DartStringAdapter(DartStringPeer::emptyString())',
-    'boolean': 'false',
-    'float': '0.0f',
-    'unrestricted float': '0.0f',
-    'double': '0.0',
-    'unrestricted double': '0.0',
-    'byte': '0',
-    'octet': '0',
-    'short': '0',
-    'unsigned short': '0',
-    'long': '0',
-    'unsigned long': '0',
-    'long long': '0',
-    'unsigned long long': '0',
-    'Dictionary': 'Dictionary()',
-    'ScriptValue': 'DartUtilities::dartToScriptValueWithNullCheck(Dart_Null())',
-    'MediaQueryListListener': 'nullptr',
-    'NodeFilter': 'nullptr',
-    'SerializedScriptValue': 'nullptr',
-    'XPathNSResolver': 'nullptr',
-}
-
-
-def default_cpp_value_for_cpp_type(idl_type):
-    idl_type = idl_type.preprocessed_type
-    add_includes_for_type(idl_type)
-    base_idl_type = idl_type.base_type
-    if base_idl_type in CPP_DEFAULT_VALUE_FOR_CPP_TYPE:
-        return CPP_DEFAULT_VALUE_FOR_CPP_TYPE[base_idl_type]
-    if base_idl_type in NON_WRAPPER_TYPES:
-        return 'nullptr'
-    format_str = 'Dart{idl_type}::toNativeWithNullCheck(Dart_Null(), exception)'
-    return format_str.format(idl_type=idl_type)
-
-
-# Override idl_type.name to not suffix orNull to the name, in Dart we always
-# test for null e.g.,
-#
-#      bool isNull = false;
-#      TYPE* result = receiver->GETTER(isNull);
-#      if (isNull)
-#          return;
-#
-def dart_name(idl_type):
-    """Return type name.
-
-    http://heycam.github.io/webidl/#dfn-type-name
-    """
-    base_type = idl_type.base_type
-    base_type_name = TYPE_NAMES.get(base_type, base_type)
-    if idl_type.native_array_element_type:
-        return idl_type.inner_name()
-    return base_type_name
-
-IdlType.name = property(dart_name)
-IdlUnionType.name = property(dart_name)
-
-
-# If True use the WithNullCheck version when converting.
-def allow_null(idl_type, extended_attributes, has_type_checking_interface):
-    if idl_type.base_type in ('DOMString', 'ByteString', 'ScalarValueString'):
-        # This logic is in cpp_types in v8_types.py, since they handle
-        # this using the V8StringResource type.  We handle it here
-        if (extended_attributes.get('TreatNullAs') == 'NullString' or
-            extended_attributes.get('TreatUndefinedAs') == 'NullString'):
-            return True
-
-        if extended_attributes.get('Default') == 'NullString':
-            return True
-
-        if extended_attributes.get('Default') == 'Undefined':
-            return True
-
-        if idl_type.is_nullable:
-            return True
-
-        return False
-    else:
-        # This logic is implemented in the methods.cpp template in V8
-        if (idl_type.is_nullable or not has_type_checking_interface):
-            return True
-
-        if extended_attributes.get('Default') == 'Undefined':
-            return True
-
-        return False
-
-
-# If True use the WithEmptyCheck version when converting.
-def allow_empty(idl_type, extended_attributes):
-    if idl_type.base_type in ('DOMString', 'ByteString', 'ScalarValueString'):
-        # This logic is in cpp_types in v8_types.py, since they handle
-        # this using the V8StringResource type.  We handle it here
-        if (extended_attributes.get('TreatNullAs') == 'EmptyString' or
-            extended_attributes.get('TreatUndefinedAs') == 'EmptyString'):
-            return True
-
-        if extended_attributes.get('Default') == 'EmptyString':
-            return True
-
-    return False