Improve handling of failed integer type conversions.

Source/bindings/scripts/code_generator_v8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 151 matching lines @@
                          "short" => 1,
                          "long" => 1,
                          "long long" => 1,
                          "unsigned short" => 1,
                          "unsigned long" => 1,
                          "unsigned long long" => 1,
                          "float" => 1,
                          "double" => 1,
                         );
 
-my %integerTypeHash = ("byte" => 1,
-                       "octet" => 1,
-                       "short" => 1,
-                       "long" => 1,
-                       "long long" => 1,
-                       "unsigned short" => 1,
-                       "unsigned long" => 1,
-                       "unsigned long long" => 1,
+# NOTE: For the unsigned types, the "UI" prefix is used (and not
+# "Ui"), so as to match onto the naming of V8Binding conversion
+# methods (and not the Typed Array naming scheme for unsigned types.)
+my %integerTypeHash = ("byte" => "Int8",
+                       "octet" => "UInt8",
+                       "short" => "Int16",
+                       "long" => "Int32",
+                       "long long" => "Int64",
+                       "unsigned short" => "UInt16",
+                       "unsigned long" => "UInt32",
+                       "unsigned long long" => "UInt64"
                       );
 
 my %nonWrapperTypes = ("CompareHow" => 1,
                        "Dictionary" => 1,
                        "EventListener" => 1,
                        "EventHandler" => 1,
                        "MediaQueryListListener" => 1,
                        "NodeFilter" => 1,
                        "SerializedScriptValue" => 1,
                        "any" => 1,
@@ skipping 1732 matching lines @@
         $code .= "static void ${attrName}AttributeSetter${forMainWorldSuffix}(v8::Local<v8::Value> jsValue, const v8::FunctionCallbackInfo<v8::Value>& info)\n";
     } else {
         $code .= "static void ${attrName}AttributeSetter${forMainWorldSuffix}(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)\n";
     }
     $code .= "{\n";
 
     my $raisesException = $attribute->extendedAttributes->{"RaisesException"};
     my $useExceptions = 1 if $raisesException && ($raisesException eq "VALUE_IS_MISSING" or $raisesException eq "Setter");
     my $hasStrictTypeChecking = 1 if $attribute->extendedAttributes->{"StrictTypeChecking"} && IsWrapperType($attrType);  # Currently only actually check interface types
 
+    # Can throw exceptions from accessors or during type conversion.
+    my $isNumberType = IsIntegerType($attribute->type);
+
     # We throw exceptions using 'ExceptionState' if the attribute explicitly
     # claims that exceptions may be raised, or if a strict type check might
     # fail, or if we're dealing with SVG, which does strange things with
     # tearoffs and read-only wrappers.
-    if ($useExceptions or $hasStrictTypeChecking or GetSVGTypeNeedingTearOff($interfaceName) or GetSVGTypeNeedingTearOff($attrType)) {
+    if ($useExceptions or $hasStrictTypeChecking or GetSVGTypeNeedingTearOff($interfaceName) or GetSVGTypeNeedingTearOff($attrType) or $isNumberType) {
         $code .= "    ExceptionState exceptionState(ExceptionState::SetterContext, \"${attrName}\", \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
     }
 
     # If the "StrictTypeChecking" extended attribute is present, and the
     # attribute's type is an interface type, then if the incoming value does not
     # implement that interface, a TypeError is thrown rather than silently
     # passing NULL to the C++ code.
     # Per the Web IDL and ECMAScript specifications, incoming values can always
     # be converted to both strings and numbers, so do not throw TypeError if the
     # attribute is of these types.
@@ skipping 406 matching lines @@
         # Append a number to an overloaded method's name to make it unique:
         $name = $name . $function->{overloadIndex};
     }
 
     my $conditionalString = GenerateConditionalString($function);
     my $code = "";
     $code .= "#if ${conditionalString}\n" if $conditionalString;
     $code .= "static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
 
-    # We throw exceptions using 'ExceptionState' if the function explicitly claims that exceptions
-    # may be raised, or for event listeners, or for security-checking, and for weird SVG stuff.
+    # We throw exceptions using 'ExceptionState' for a function if:
+    #   - it explicitly claims that exceptions may be raised (or should be if type checks fail.)
+    #   - event listeners
+    #   - security-checking
+    #   - weird SVG stuff.

[jsbell, 2014/01/02 18:03:23]

nit: inconsistent punctuation in the list

+    #   - takes a parameter that might raise an exception on conversion.
+    #
     my $isEventListener = $name eq "addEventListener" || $name eq "removeEventListener";
     my $isSecurityCheckNecessary = $interface->extendedAttributes->{"CheckSecurity"} && !$function->extendedAttributes->{"DoNotCheckSecurity"};
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
+    my $hasStrictTypeChecking = $function->extendedAttributes->{"StrictTypeChecking"};
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
     my $isNonListSVGType = $svgNativeType && !($interfaceName =~ /List$/);
 
-    my $hasExceptionState = 0;
-    if ($raisesExceptions || $isEventListener || $isSecurityCheckNecessary || $isNonListSVGType || HasSerializedScriptValueParameter($function)) {
+    my $hasExceptionState = $raisesExceptions || $isEventListener || $isSecurityCheckNecessary || $isNonListSVGType || HasExceptionRaisingParameter($function);
+    if ($hasExceptionState) {
         $code .= "    ExceptionState exceptionState(ExceptionState::ExecutionContext, \"${unoverloadedName}\", \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
-        $hasExceptionState = 1;
     }
 
     if ($isEventListener) {
         my $lookupType = ($name eq "addEventListener") ? "OrCreate" : "Only";
         my $passRefPtrHandling = ($name eq "addEventListener") ? "" : ".get()";
         my $hiddenDependencyAction = ($name eq "addEventListener") ? "create" : "remove";
 
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         AddToImplIncludes("bindings/v8/V8EventListenerList.h");
         AddToImplIncludes("core/frame/DOMWindow.h");
@@ skipping 67 matching lines @@
         $code .= "        exceptionState.throwIfNeeded();\n";
         $code .= "        return;\n";
         $code .= "    }\n";
 END
     }
 
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, $forMainWorldSuffix, $hasExceptionState);
     $code .= $parameterCheckString;
 
     # Build the function call string.
-    $code .= GenerateFunctionCallString($function, $paramIndex, "    ", $interface, $forMainWorldSuffix, %replacements);
+    $code .= GenerateFunctionCallString($function, $paramIndex, "    ", $interface, $forMainWorldSuffix, $hasExceptionState, %replacements);
     $code .= "}\n";
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     $code .= "\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateCallWith
 {
     my $callWith = shift;
     return ([], "") unless $callWith;
@@ skipping 87 matching lines @@
     foreach my $parameter (@{$function->parameters}) {
         my $humanFriendlyIndex = $paramIndex + 1;
         my $nativeType = GetNativeType($parameter->type, $parameter->extendedAttributes, "parameter");
 
         # Optional arguments without [Default=...] should generate an early call with fewer arguments.
         # Optional Dictionary arguments always considered to have default of empty dictionary.
         if ($parameter->isOptional && !$parameter->extendedAttributes->{"Default"} && $nativeType ne "Dictionary" && !IsCallbackInterface($parameter->type)) {
             $parameterCheckString .= <<END;
     if (UNLIKELY(info.Length() <= $paramIndex)) {
 END
-            $parameterCheckString .= GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interface, $forMainWorldSuffix, %replacements);
+            $parameterCheckString .= GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interface, $forMainWorldSuffix, $hasExceptionState, %replacements);
             $parameterCheckString .= <<END;
         return;
     }
 END
         }
 
         my $parameterName = $parameter->name;
         if (IsCallbackInterface($parameter->type)) {
             my $v8ClassName = "V8" . $parameter->type;
             AddToImplIncludes("$v8ClassName.h");
@@ skipping 190 matching lines @@
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $overloadedIndexString = "";
     if ($function->overloadedIndex > 0) {
         $overloadedIndexString .= $function->overloadedIndex;
     }
 
     my $constructorRaisesException = $interface->extendedAttributes->{"RaisesException"} && $interface->extendedAttributes->{"RaisesException"} eq "Constructor";
-    my $raisesExceptions = $function->extendedAttributes->{"RaisesException"} || $constructorRaisesException || HasSerializedScriptValueParameter($function);
+    my $hasExceptionState = $function->extendedAttributes->{"RaisesException"} || $constructorRaisesException || HasExceptionRaisingParameter($function);
 
     my @beforeArgumentList;
     my @afterArgumentList;
     my $code = "";
     $code .= <<END;
 static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
 
+    if ($hasExceptionState) {
+        $code .= "    ExceptionState exceptionState(ExceptionState::ConstructionContext, \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
+    }
     if ($function->overloadedIndex == 0) {
-        my $hasExceptionState = 0;
         $code .= GenerateArgumentsCountCheck($function, $interface, $hasExceptionState);
     }
 
-    if ($raisesExceptions) {
-        $code .= "    ExceptionState exceptionState(ExceptionState::ConstructionContext, \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
-    }
-
     # FIXME: Currently [Constructor(...)] does not yet support optional arguments without [Default=...]
-    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "", $raisesExceptions);
+    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "", $hasExceptionState);
     $code .= $parameterCheckString;
 
     if ($interface->extendedAttributes->{"ConstructorCallWith"}) {
         if (ExtendedAttributeContains($interface->extendedAttributes->{"ConstructorCallWith"}, "ExecutionContext")) {
             push(@beforeArgumentList, "context");
             $code .= "    ExecutionContext* context = getExecutionContext();\n";
         }
         if (ExtendedAttributeContains($interface->extendedAttributes->{"ConstructorCallWith"}, "Document")) {
             push(@beforeArgumentList, "document");
             $code .= "    Document& document = *toDocument(getExecutionContext());\n";
@@ skipping 253 matching lines @@
 
 sub GenerateNamedConstructor
 {
     my $function = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $constructorRaisesException = $interface->extendedAttributes->{"RaisesException"} && $interface->extendedAttributes->{"RaisesException"} eq "Constructor";
-    my $raisesExceptions = $function->extendedAttributes->{"RaisesException"} || $constructorRaisesException || HasSerializedScriptValueParameter($function);
+    my $raisesExceptions = $function->extendedAttributes->{"RaisesException"} || $constructorRaisesException || HasExceptionRaisingParameter($function);
 
     my $maybeObserveFeature = GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     my $maybeDeprecateFeature = GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
 
     my @beforeArgumentList;
     my @afterArgumentList;
 
     my $toActiveDOMObject = "0";
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         $toActiveDOMObject = "${v8ClassName}::toActiveDOMObject";
@@ skipping 20 matching lines @@
     $code .= <<END;
     Document* document = currentDocument();
     ASSERT(document);
 
     // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} instance
     // may end up being the only node in the map and get garbage-collected prematurely.
     toV8(document, info.Holder(), info.GetIsolate());
 
 END
 
-    if ($raisesExceptions) {
+    my $hasExceptionState = $raisesExceptions;
+    if ($hasExceptionState) {
         $code .= "    ExceptionState exceptionState(ExceptionState::ConstructionContext, \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
     }
-
-    my $hasExceptionState = $raisesExceptions;
     $code .= GenerateArgumentsCountCheck($function, $interface, $hasExceptionState);
 
-    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "", $raisesExceptions);
+    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "", $hasExceptionState);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "*document");
 
     if ($constructorRaisesException) {
         push(@afterArgumentList, "exceptionState");
     }
 
     my @argumentList;
     my $index = 0;
@@ skipping 566 matching lines @@
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateImplementationIndexedPropertySetter
 {
     my $interface = shift;
     my $indexedSetterFunction = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $methodName = GetImplName($indexedSetterFunction);
+    my $interfaceName = $interface->name;
 
     my $type = $indexedSetterFunction->parameters->[1]->type;
     my $raisesExceptions = $indexedSetterFunction->extendedAttributes->{"RaisesException"};
     my $treatNullAs = $indexedSetterFunction->parameters->[1]->extendedAttributes->{"TreatNullAs"};
     my $treatUndefinedAs = $indexedSetterFunction->parameters->[1]->extendedAttributes->{"TreatUndefinedAs"};
-    my $asSetterValue = 0;
 
     my $code = "static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
+
+    my $extraArguments = "";
+    if ($raisesExceptions || IsIntegerType($type)) {
+        $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
+        if ($raisesExceptions) {
+            $extraArguments = ", exceptionState";
+        }
+    }
+
+    my $asSetterValue = 0;
     $code .= "    ${implClassName}* collection = ${v8ClassName}::toNative(info.Holder());\n";
     $code .= JSValueToNativeStatement($indexedSetterFunction->parameters->[1]->type, $indexedSetterFunction->extendedAttributes, $asSetterValue, "jsValue", "propertyValue", "    ", "info.GetIsolate()");
 
-    my $extraArguments = "";
-    if ($raisesExceptions) {
-        $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
-        $extraArguments = ", exceptionState";
-    }
     my @conditions = ();
     my @statements = ();
     if ($treatNullAs && $treatNullAs ne "NullString") {
         push @conditions, "jsValue->IsNull()";
         push @statements, "collection->${treatNullAs}(index$extraArguments);";
     }
     if ($treatUndefinedAs && $treatUndefinedAs ne "NullString") {
         push @conditions, "jsValue->IsUndefined()";
         push @statements, "collection->${treatUndefinedAs}(index$extraArguments);";
     }
@@ skipping 268 matching lines @@
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateImplementationNamedPropertySetter
 {
     my $interface = shift;
     my $namedSetterFunction = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $methodName = GetImplName($namedSetterFunction);
+    my $interfaceName = $interface->name;
 
+    my $type = $namedSetterFunction->parameters->[1]->type;
     my $raisesExceptions = $namedSetterFunction->extendedAttributes->{"RaisesException"};
     my $treatNullAs = $namedSetterFunction->parameters->[1]->extendedAttributes->{"TreatNullAs"};
     my $treatUndefinedAs = $namedSetterFunction->parameters->[1]->extendedAttributes->{"TreatUndefinedAs"};
-    my $asSetterValue = 0;
 
     my $code = "static void namedPropertySetter(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
     if (!$namedSetterFunction->extendedAttributes->{"OverrideBuiltins"}) {
         $code .= "    if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())\n";
         $code .= "        return;\n";
         $code .= "    if (info.Holder()->HasRealNamedCallbackProperty(name))\n";
         $code .= "        return;\n";
         $code .= "    if (info.Holder()->HasRealNamedProperty(name))\n";
         $code .= "        return;\n";
     }
+
+    my $extraArguments = "";
+    if ($raisesExceptions || IsIntegerType($type)) {
+        $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
+        if ($raisesExceptions) {
+            $extraArguments = ", exceptionState";
+        }
+    }
+
+    my $asSetterValue = 0;
     $code .= "    ${implClassName}* collection = ${v8ClassName}::toNative(info.Holder());\n";
     $code .= JSValueToNativeStatement($namedSetterFunction->parameters->[0]->type, $namedSetterFunction->extendedAttributes, $asSetterValue, "name", "propertyName", "    ", "info.GetIsolate()");
     $code .= JSValueToNativeStatement($namedSetterFunction->parameters->[1]->type, $namedSetterFunction->extendedAttributes, $asSetterValue, "jsValue", "propertyValue", "    ", "info.GetIsolate()");
-    my $extraArguments = "";
-    if ($raisesExceptions) {
-        $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
-        $extraArguments = ", exceptionState";
-    }
 
     my @conditions = ();
     my @statements = ();
     if ($treatNullAs && $treatNullAs ne "NullString") {
         push @conditions, "jsValue->IsNull()";
         push @statements, "collection->${treatNullAs}(propertyName$extraArguments);";
     }
     if ($treatUndefinedAs && $treatUndefinedAs ne "NullString") {
         push @conditions, "jsValue->IsUndefined()";
         push @statements, "collection->${treatUndefinedAs}(propertyName$extraArguments);";
@@ skipping 1131 matching lines @@
     return "WebCore";
 }
 
 sub GenerateFunctionCallString
 {
     my $function = shift;
     my $numberOfParameters = shift;
     my $indent = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
+    my $hasExceptionState = shift;
     my %replacements = @_;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $name = GetImplName($function);
     my $returnType = $function->type;
     my $nativeReturnType = GetNativeType($returnType, {}, "");
     my $code = "";
 
     my $isSVGTearOffType = (IsSVGTypeNeedingTearOff($returnType) and not $interfaceName =~ /List$/);
@@ skipping 29 matching lines @@
         if ($index eq $numberOfParameters) {
             last;
         }
         my $paramName = $parameter->name;
         my $paramType = $parameter->type;
 
         if ($replacements{$paramName}) {
             push @arguments, $replacements{$paramName};
         } elsif (IsSVGTypeNeedingTearOff($parameter->type) and not $interfaceName =~ /List$/) {
             push @arguments, "$paramName->propertyReference()";
-            $code .= <<END;
+            if ($hasExceptionState) {
+                $code .= <<END;
+    if (!$paramName) {
+        exceptionState.throwTypeError(\"parameter $humanFriendlyIndex is not of type '${ \$parameter->type }'.\");
+        exceptionState.throwIfNeeded();
+        return;
+    }
+END
+            } else {
+                $code .= <<END;
     if (!$paramName) {
         throwTypeError(ExceptionMessages::failedToExecute(\"$name\", \"$interfaceName\", \"parameter $humanFriendlyIndex is not of type '${ \$parameter->type }'.\"), info.GetIsolate());
         return;
     }
 END
+           }
         } elsif ($parameter->type eq "SVGMatrix" and $interfaceName eq "SVGTransformList") {
             push @arguments, "$paramName.get()";
         } elsif (IsNullableParameter($parameter)) {
             push @arguments, "${paramName}IsNull ? 0 : &$paramName";
         } elsif (IsCallbackInterface($paramType) or $paramType eq "NodeFilter" or $paramType eq "XPathNSResolver") {
             push @arguments, "$paramName.release()";
         } else {
             push @arguments, $paramName;
         }
         $index++;
@@ skipping 168 matching lines @@
     my $nativeType = GetNativeType($type, $extendedAttributes, "parameter");
     my $native_value = JSValueToNative($type, $extendedAttributes, $argIndexOrZero, $jsValue, $getIsolate);
     my $code = "";
     if ($type eq "DOMString" || IsEnumType($type)) {
         die "Wrong native type passed: $nativeType" unless $nativeType =~ /^V8StringResource/;
         if ($type eq "DOMString" or IsEnumType($type)) {
             $code .= $indent . "V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID($nativeType, $variableName, $native_value);\n"
         } else {
             $code .= $indent . "$nativeType $variableName($native_value, true);\n";
         }
-    } elsif ($extendedAttributes->{"EnforceRange"}) {
-        $code .= $indent . "V8TRYCATCH_WITH_TYPECHECK_VOID($nativeType, $variableName, $native_value, $getIsolate);\n";
+    } elsif (IsIntegerType($type)) {
+        $code .= $indent . "V8TRYCATCH_EXCEPTION_VOID($nativeType, $variableName, $native_value, exceptionState);\n";
     } else {
         $code .= $indent . "V8TRYCATCH_VOID($nativeType, $variableName, $native_value);\n";
     }
     return $code;
 }
 
 
 sub JSValueToNative
 {
     my $type = shift;
     my $extendedAttributes = shift;
     # Argument position (1-indexed) or 0 if for a setter's value.
     my $argIndexOrZero = shift;
     my $value = shift;
     my $getIsolate = shift;
 
-    my $intConversion = $extendedAttributes->{"EnforceRange"} ? "EnforceRange" : "NormalConversion";
-
     return "$value->BooleanValue()" if $type eq "boolean";
     return "static_cast<$type>($value->NumberValue())" if $type eq "float" or $type eq "double";
 
-    if ($intConversion ne "NormalConversion") {
-        return "toInt8($value, $intConversion, ok)" if $type eq "byte";
-        return "toUInt8($value, $intConversion, ok)" if $type eq "octet";
-        return "toInt16($value, $intConversion, ok)" if $type eq "short";
-        return "toUInt16($value, $intConversion, ok)" if $type eq "unsigned short";
-        return "toInt32($value, $intConversion, ok)" if $type eq "long";
-        return "toUInt32($value, $intConversion, ok)" if $type eq "unsigned long";
-        return "toInt64($value, $intConversion, ok)" if $type eq "long long";
-        return "toUInt64($value, $intConversion, ok)" if $type eq "unsigned long long";
-    } else {
-        return "toInt8($value)" if $type eq "byte";
-        return "toUInt8($value)" if $type eq "octet";
-        return "toInt16($value)" if $type eq "short";
-        return "toUInt16($value)" if $type eq "unsigned short";
-        return "toInt32($value)" if $type eq "long";
-        return "toUInt32($value)" if $type eq "unsigned long";
-        return "toInt64($value)" if $type eq "long long";
-        return "toUInt64($value)" if $type eq "unsigned long long";
+    if (IsIntegerType($type)) {
+        my $conversion = "to" . $integerTypeHash{$type} . "($value";
+        if ($extendedAttributes->{"EnforceRange"}) {
+            return "${conversion}, EnforceRange, exceptionState)";
+        } else {
+            return "${conversion}, exceptionState)";
+        }
     }
     return "static_cast<Range::CompareHow>($value->Int32Value())" if $type eq "CompareHow";
     return "toWebCoreDate($value)" if $type eq "Date";
 
     if ($type eq "DOMString" or IsEnumType($type)) {
         return $value;
     }
 
     if ($type eq "SerializedScriptValue") {
         AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
@@ skipping 885 matching lines @@
     my $interface = shift;
 
     return 1 if ExtendedAttributeContains($interface->extendedAttributes->{"Custom"}, "ToV8");
     return 1 if ExtendedAttributeContains($interface->extendedAttributes->{"Custom"}, "Wrap");
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
-sub HasSerializedScriptValueParameter
+sub HasExceptionRaisingParameter
 {
     my $function = shift;
 
     foreach my $parameter (@{$function->parameters}) {
         if ($parameter->type eq "SerializedScriptValue") {
             return 1;
+        } elsif (IsIntegerType($parameter->type)) {
+            return 1;
         }
     }
     return 0;
 }
 
 1;