Improve handling of dictionary 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,
+                      );
+
 my %nonWrapperTypes = ("CompareHow" => 1,
                        "Dictionary" => 1,
                        "EventListener" => 1,
                        "EventHandler" => 1,
                        "MediaQueryListListener" => 1,
                        "NodeFilter" => 1,
                        "SerializedScriptValue" => 1,
                        "any" => 1,
                       );
 
@@ skipping 830 matching lines @@
 
 template<class CallbackInfo, class Wrappable>
 inline void v8SetReturnValueFast(const CallbackInfo& callbackInfo, PassRefPtr<${nativeType} > impl, Wrappable* wrappable)
 {
     v8SetReturnValueFast(callbackInfo, impl.get(), wrappable);
 }
 
 END
 
     if (IsConstructorTemplate($interface, "Event")) {
-        $header{nameSpaceWebCore}->add("bool fill${implClassName}Init(${implClassName}Init&, const Dictionary&);\n\n");
+        $header{nameSpaceWebCore}->add("bool fill${implClassName}Init(${implClassName}Init&, const Dictionary&, ExceptionState&);\n\n");
     }
 }
 
 sub GetInternalFields
 {
     my $interface = shift;
 
     my @customInternalFields = ();
     # Event listeners on DOM nodes are explicitly supported in the GC controller.
     if (!InheritsInterface($interface, "Node") &&
@@ skipping 1823 matching lines @@
     }
 }
 
 sub GenerateEventConstructor
 {
     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 @anyAttributeNames;
     my @serializableAnyAttributeNames;
     foreach my $attribute (@{$interface->attributes}) {
         if ($attribute->type eq "any") {
             push(@anyAttributeNames, $attribute->name);
             if (!$attribute->extendedAttributes->{"Unserializable"}) {
                 push(@serializableAnyAttributeNames, $attribute->name);
             }
         }
     }
@@ skipping 12 matching lines @@
 END
 
     foreach my $attrName (@anyAttributeNames) {
         $implementation{nameSpaceInternal}->add("    v8::Local<v8::Value> ${attrName};\n");
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
     ${implClassName}Init eventInit;
     if (info.Length() >= 2) {
         V8TRYCATCH_VOID(Dictionary, options, Dictionary(info[1], info.GetIsolate()));
-        if (!fill${implClassName}Init(eventInit, options))
+        ExceptionState exceptionState(info.Holder(), info.GetIsolate());
+        if (!fill${implClassName}Init(eventInit, options, exceptionState)) {
+            exceptionState.throwIfNeeded();
             return;
+        }
 END
 
     # Store 'any'-typed properties on the wrapper to avoid leaking them between isolated worlds.
     foreach my $attrName (@anyAttributeNames) {
         $implementation{nameSpaceInternal}->add(<<END);
         options.get("${attrName}", ${attrName});
         if (!${attrName}.IsEmpty())
             info.Holder()->SetHiddenValue(V8HiddenPropertyName::${attrName}(info.GetIsolate()), ${attrName});
 END
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
     }
+END
 
-    RefPtr<${implClassName}> event = ${implClassName}::create(type, eventInit);
+    my $exceptionStateArgument = "";
+    if ($constructorRaisesException) {
+        ${exceptionStateArgument} = ", exceptionState";
+        $implementation{nameSpaceInternal}->add(<<END);
+    ExceptionState exceptionState(info.Holder(), info.GetIsolate());
 END
+    }
+
+    $implementation{nameSpaceInternal}->add(<<END);
+    RefPtr<${implClassName}> event = ${implClassName}::create(type, eventInit${exceptionStateArgument});
+END
+
+    if ($constructorRaisesException) {
+        $implementation{nameSpaceInternal}->add(<<END);
+    if (exceptionState.throwIfNeeded())
+        return;
+END
+    }
 
     if (@serializableAnyAttributeNames) {
         # If we're in an isolated world, create a SerializedScriptValue and store it in the event for
         # later cloning if the property is accessed from another world.
         # The main world case is handled lazily (in Custom code).
         AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         $implementation{nameSpaceInternal}->add("    if (isolatedWorldForIsolate(info.GetIsolate())) {\n");
         foreach my $attrName (@serializableAnyAttributeNames) {
             my $setter = "setSerialized" . FirstLetterToUpperCase($attrName);
             $implementation{nameSpaceInternal}->add(<<END);
         if (!${attrName}.IsEmpty())
             event->${setter}(SerializedScriptValue::createAndSwallowExceptions(${attrName}, info.GetIsolate()));
 END
         }
         $implementation{nameSpaceInternal}->add("    }\n\n");
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
     v8::Handle<v8::Object> wrapper = info.Holder();
     V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(event.release(), &${v8ClassName}::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
     v8SetReturnValue(info, wrapper);
 }
 END
 
     my $code = "";
     $code .= <<END;
-bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options)
+bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options, ExceptionState& exceptionState)
 {
 END
 
     if ($interface->parent) {
         my $interfaceBase = $interface->parent;
         $code .= <<END;
-    if (!fill${interfaceBase}Init(eventInit, options))
+    if (!fill${interfaceBase}Init(eventInit, options, exceptionState))
         return false;
 
 END
     }
 
     foreach my $attribute (@{$interface->attributes}) {
         if ($attribute->extendedAttributes->{"InitializedByEventConstructor"}) {
             if ($attribute->type ne "any") {
                 my $attributeName = $attribute->name;
                 my $attributeImplName = GetImplName($attribute);
                 my $deprecation = $attribute->extendedAttributes->{"DeprecateAs"};
-                my $dictionaryGetter = "options.get(\"$attributeName\", eventInit.$attributeImplName)";
+
+                my $typeNameArgument = "";
+                my $nullableArgument = "";
+                my $integerConversionArgument = "";
+
+                # Construct the arguments to the corresponding Dictionary.convert() method.
+                if ($attribute->extendedAttributes->{"EnforceRange"}) {
+                    $integerConversionArgument = ", EnforceRange";
+                } elsif ($attribute->extendedAttributes->{"Clamp"}) {
+                    $integerConversionArgument = ", Clamp";
+                } elsif (IsIntegerType($attribute->type)) {
+                    $integerConversionArgument = ", NormalConversion";
+                } elsif ($attribute->type eq "boolean" || $attribute->type eq "double") {
+                    ;
+                } elsif ($attribute->type eq "DOMString" || IsEnumType($attribute->type) || IsCallbackFunctionType($attribute->type)) {
+                    ;
+                } elsif ($attribute->isNullable) {
+                    $nullableArgument = ", true";
+                    $typeNameArgument = ", \"" . $attribute->type . "\"";
+                } else {
+                    $nullableArgument = ", false";
+                    $typeNameArgument = ", \"" . $attribute->type . "\"";
+                }
+                if ($typeNameArgument eq ", \"object\"") {
+                    # Too generic, leave as empty for equally good error message.
+                    $typeNameArgument = ", \"\"";
+                }
+
+                my $dictionaryGetter = "options.convert(\"$attributeName\"${typeNameArgument}${nullableArgument}${integerConversionArgument}, eventInit.$attributeImplName, exceptionState)";
                 if ($attribute->extendedAttributes->{"DeprecateAs"}) {
-                    $code .= "    if ($dictionaryGetter)\n";
-                    $code .= "    " . GenerateDeprecationNotification($attribute->extendedAttributes->{"DeprecateAs"});
+                    $code .= "    if ($dictionaryGetter) {\n";
+                    $code .= "        if (options.hasProperty(\"$attributeName\"))\n";
+                    $code .= "        " . GenerateDeprecationNotification($attribute->extendedAttributes->{"DeprecateAs"});
+                    $code .= "    } else {\n";
+                    $code .= "        return false;\n";
+                    $code .= "    }\n";
                 } else {
-                    $code .= "    $dictionaryGetter;\n";
+                    $code .= "    if (!$dictionaryGetter)\n";
+                    $code .= "        return false;\n";
                 }
             }
         }
     }
 
     $code .= <<END;
     return true;
 }
 
 END
@@ skipping 2958 matching lines @@
 }
 
 sub IsPrimitiveType
 {
     my $type = shift;
 
     return 1 if $primitiveTypeHash{$type};
     return 0;
 }
 
+sub IsIntegerType
+{
+    my $type = shift;
+
+    return 1 if $integerTypeHash{$type};
+    return 0;
+}
+
 sub IsCallbackFunctionType
 {
     my $type = shift;
 
     return 1 if $callbackFunctionTypeHash{$type};
     return 0;
 }
 
 sub IsEnumType
 {
@@ skipping 381 matching lines @@
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"CustomWrap"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
 1;