IDL: Drop value conversion (V8 -> C++) macros from generated code

Source/bindings/tests/results/core/V8TestDictionary.cpp

 // 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.
 
 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
 
 #include "config.h"
 #include "V8TestDictionary.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/UnionTypesCore.h"
 #include "bindings/core/v8/V8Element.h"
 #include "bindings/core/v8/V8EventTarget.h"
 #include "bindings/core/v8/V8InternalDictionary.h"
 #include "bindings/core/v8/V8TestInterface.h"
 #include "bindings/core/v8/V8TestInterface2.h"
 #include "bindings/core/v8/V8TestInterfaceGarbageCollected.h"
 #include "bindings/core/v8/V8TestInterfaceWillBeGarbageCollected.h"
 #include "bindings/core/v8/V8Uint8Array.h"
 #include "core/frame/UseCounter.h"
 
 namespace blink {
 
-void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
+bool V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
 {
     if (isUndefinedOrNull(v8Value))
-        return;
+        return true;
     if (!v8Value->IsObject()) {
         exceptionState.throwTypeError("cannot convert to dictionary.");
-        return;
+        return false;
     }
 
     v8::Local<v8::Object> v8Object = v8Value->ToObject(isolate);
     v8::TryCatch block;
     v8::Local<v8::Value> booleanMemberValue = v8Object->Get(v8String(isolate, "booleanMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         bool booleanMember = booleanMemberValue->BooleanValue();
         impl.setBooleanMember(booleanMember);
     }
 
     v8::Local<v8::Value> createValue = v8Object->Get(v8String(isolate, "create"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (createValue.IsEmpty() || createValue->IsUndefined()) {
         // Do nothing.
     } else {
         bool create = createValue->BooleanValue();
         impl.setCreateMember(create);
     }
 
     v8::Local<v8::Value> deprecatedCreateMemberValue = v8Object->Get(v8String(isolate, "deprecatedCreateMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         UseCounter::countDeprecationIfNotPrivateScript(isolate, callingExecutionContext(isolate), UseCounter::CreateMember);
         bool deprecatedCreateMember = deprecatedCreateMemberValue->BooleanValue();
         impl.setCreateMember(deprecatedCreateMember);
     }
 
     v8::Local<v8::Value> doubleOrNullMemberValue = v8Object->Get(v8String(isolate, "doubleOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (doubleOrNullMemberValue->IsNull()) {
         impl.setDoubleOrNullMemberToNull();
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
+        double doubleOrNullMember = toDouble(doubleOrNullMemberValue, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setDoubleOrNullMember(doubleOrNullMember);
     }
 
     v8::Local<v8::Value> doubleOrStringMemberValue = v8Object->Get(v8String(isolate, "doubleOrStringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         DoubleOrString doubleOrStringMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), exceptionState);
+        if (!V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState))
+            return false;
         impl.setDoubleOrStringMember(doubleOrStringMember);
     }
 
     v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (elementOrNullMemberValue->IsNull()) {
         impl.setElementOrNullMemberToNull();
     } else {
         Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
         if (!elementOrNullMember && !elementOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
-            return;
+            return false;
         }
         impl.setElementOrNullMember(elementOrNullMember);
     }
 
     v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
+        V8StringResource<> enumMember = enumMemberValue;
+        if (!enumMember.prepare(exceptionState))
+            return false;
         String string = enumMember;
         if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
             exceptionState.throwTypeError("member enumMember ('" + string + "') is not a valid enum value.");
-            return;
+            return false;
         }
         impl.setEnumMember(enumMember);
     }
 
     v8::Local<v8::Value> eventTargetMemberValue = v8Object->Get(v8String(isolate, "eventTargetMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         EventTarget* eventTargetMember = toEventTarget(isolate, eventTargetMemberValue);
         if (!eventTargetMember && !eventTargetMemberValue->IsNull()) {
             exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
-            return;
+            return false;
         }
         impl.setEventTargetMember(eventTargetMember);
     }
 
     v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+        Vector<InternalDictionary> internalDictionarySequenceMember = toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
     }
 
     v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
+        int longMember = toInt32(longMemberValue, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setLongMember(longMember);
     }
 
     v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
         if (!objectMember.isObject()) {
             exceptionState.throwTypeError("member objectMember is not an object.");
-            return;
+            return false;
         }
         impl.setObjectMember(objectMember);
     }
 
     v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (objectOrNullMemberValue->IsNull()) {
         impl.setObjectOrNullMemberToNull();
     } else {
         ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
         if (!objectOrNullMember.isObject()) {
             exceptionState.throwTypeError("member objectOrNullMember is not an object.");
-            return;
+            return false;
         }
         impl.setObjectOrNullMember(objectOrNullMember);
     }
 
     v8::Local<v8::Value> otherDoubleOrStringMemberValue = v8Object->Get(v8String(isolate, "otherDoubleOrStringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         DoubleOrString otherDoubleOrStringMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState), exceptionState);
+        if (!V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState))
+            return false;
         impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
     }
 
     v8::Local<v8::Value> restrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "restrictedDoubleMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (restrictedDoubleMemberValue.IsEmpty() || restrictedDoubleMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(double, restrictedDoubleMember, toRestrictedDouble(restrictedDoubleMemberValue, exceptionState), exceptionState);
+        double restrictedDoubleMember = toRestrictedDouble(restrictedDoubleMemberValue, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setRestrictedDoubleMember(restrictedDoubleMember);
     }
 
     v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
+        Vector<String> stringArrayMember = toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setStringArrayMember(stringArrayMember);
     }
 
     v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
+        V8StringResource<> stringMember = stringMemberValue;
+        if (!stringMember.prepare(exceptionState))
+            return false;
         impl.setStringMember(stringMember);
     }
 
     v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (stringOrNullMemberValue->IsNull()) {
         impl.setStringOrNullMemberToNull();
     } else {
-        TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
+        V8StringResource<> stringOrNullMember = stringOrNullMemberValue;
+        if (!stringOrNullMember.prepare(exceptionState))
+            return false;
         impl.setStringOrNullMember(stringOrNullMember);
     }
 
     v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+        Vector<String> stringSequenceMember = toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setStringSequenceMember(stringSequenceMember);
     }
 
     v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue = v8Object->Get(v8String(isolate, "testInterface2OrUint8ArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState), exceptionState);
+        if (!V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState))
+            return false;
         impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
     }
 
     v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
         if (!testInterfaceGarbageCollectedMember && !testInterfaceGarbageCollectedMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
     }
 
     v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
         impl.setTestInterfaceGarbageCollectedOrNullMemberToNull();
     } else {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
         if (!testInterfaceGarbageCollectedOrNullMember && !testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
     }
 
     v8::Local<v8::Value> testInterfaceMemberValue = v8Object->Get(v8String(isolate, "testInterfaceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
         if (!testInterfaceMember && !testInterfaceMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
-            return;
+            return false;
         }
         impl.setTestInterfaceMember(testInterfaceMember);
     }
 
     v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (testInterfaceOrNullMemberValue->IsNull()) {
         impl.setTestInterfaceOrNullMemberToNull();
     } else {
         TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
         if (!testInterfaceOrNullMember && !testInterfaceOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
-            return;
+            return false;
         }
         impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
     }
 
     v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
         if (!testInterfaceWillBeGarbageCollectedMember && !testInterfaceWillBeGarbageCollectedMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceWillBeGarbageCollectedMember is not of type TestInterfaceWillBeGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
     }
 
     v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
         impl.setTestInterfaceWillBeGarbageCollectedOrNullMemberToNull();
     } else {
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
         if (!testInterfaceWillBeGarbageCollectedOrNullMember && !testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceWillBeGarbageCollectedOrNullMember is not of type TestInterfaceWillBeGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
     }
 
     v8::Local<v8::Value> uint8ArrayMemberValue = v8Object->Get(v8String(isolate, "uint8ArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         DOMUint8Array* uint8ArrayMember = uint8ArrayMemberValue->IsUint8Array() ? V8Uint8Array::toImpl(v8::Local<v8::Uint8Array>::Cast(uint8ArrayMemberValue)) : 0;
         if (!uint8ArrayMember && !uint8ArrayMemberValue->IsNull()) {
             exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
-            return;
+            return false;
         }
         impl.setUint8ArrayMember(uint8ArrayMember);
     }
 
     v8::Local<v8::Value> unrestrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "unrestrictedDoubleMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(double, unrestrictedDoubleMember, toDouble(unrestrictedDoubleMemberValue, exceptionState), exceptionState);
+        double unrestrictedDoubleMember = toDouble(unrestrictedDoubleMemberValue, exceptionState);
+        if (exceptionState.hadException())
+            return false;
         impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
     }
 
+    return true;
 }
 
 v8::Local<v8::Value> toV8(const TestDictionary& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> v8Object = v8::Object::New(isolate);
     toV8TestDictionary(impl, v8Object, creationContext, isolate);
     return v8Object;
 }
 
 void toV8TestDictionary(const TestDictionary& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
@@ skipping 127 matching lines @@
 }
 
 TestDictionary NativeValueTraits<TestDictionary>::nativeValue(const v8::Local<v8::Value>& value, v8::Isolate* isolate, ExceptionState& exceptionState)
 {
     TestDictionary impl;
     V8TestDictionary::toImpl(isolate, value, impl, exceptionState);
     return impl;
 }
 
 } // namespace blink