Migrate bindings constructors to the new ExceptionState model.

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 2746 matching lines @@
     }
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($header . $code);
 }
 
 sub GenerateSingleConstructorCallback
 {
     my $interface = shift;
     my $function = shift;
 
+    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;
 
     my @beforeArgumentList;
     my @afterArgumentList;
     my $code = "";
     $code .= <<END;
 static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
 
     if ($function->overloadedIndex == 0) {
         my $hasExceptionState = 0;
         $code .= GenerateArgumentsCountCheck($function, $interface, $hasExceptionState);
     }
 
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
-        $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
+        $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, "");
     $code .= $parameterCheckString;
 
     if ($interface->extendedAttributes->{"ConstructorCallWith"}) {
         if (ExtendedAttributeContains($interface->extendedAttributes->{"ConstructorCallWith"}, "ExecutionContext")) {
             push(@beforeArgumentList, "context");
             $code .= "    ExecutionContext* context = getExecutionContext();\n";
@@ skipping 95 matching lines @@
         foreach my $constructor (@{$interface->constructors}) {
             GenerateSingleConstructorCallback($interface, $constructor);
         }
         GenerateOverloadedConstructorCallback($interface);
     }
 }
 
 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);
             }
         }
     }
 
     AddToImplIncludes("bindings/v8/Dictionary.h");
     $implementation{nameSpaceInternal}->add(<<END);
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, \"${interfaceName}\", info.Holder(), info.GetIsolate());
     if (info.Length() < 1) {
-        throwTypeError(ExceptionMessages::failedToConstruct("$interfaceName", "An event name must be provided."), info.GetIsolate());
+        exceptionState.throwTypeError("An event name must be provided.");
+        exceptionState.throwIfNeeded();
         return;
     }
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, info[0]);
 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()));
-        ExceptionState exceptionState(info.Holder(), info.GetIsolate());
         if (!initialize${implClassName}(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
 
     my $exceptionStateArgument = "";
     if ($constructorRaisesException) {
         ${exceptionStateArgument} = ", exceptionState";
-        AddToImplIncludes("bindings/v8/ExceptionState.h");
-        $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;
@@ skipping 91 matching lines @@
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 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;
 
     my $maybeObserveFeature = GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     my $maybeDeprecateFeature = GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
 
     my @beforeArgumentList;
     my @afterArgumentList;
@@ skipping 27 matching lines @@
     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) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
-        my $interfaceName = $interface->name;
         $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);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "*document");
@@ skipping 3238 matching lines @@
 
     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;
 }
 
 1;