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"
@@ skipping 62 matching lines @@
     v8::Local<v8::Value> doubleOrNullMemberValue = v8Object->Get(v8String(isolate, "doubleOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setDoubleOrNullMember(doubleOrNullMember);
     }
 
     v8::Local<v8::Value> doubleOrStringMemberValue = v8Object->Get(v8String(isolate, "doubleOrStringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         DoubleOrString doubleOrStringMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), exceptionState);
+        V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState);
+        if (exceptionState.hadException())
+            return;
         impl.setDoubleOrStringMember(doubleOrStringMember);
     }
 
     v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         }
         impl.setElementOrNullMember(elementOrNullMember);
     }
 
     v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
+        V8StringResource<> enumMember = enumMemberValue;
+        if (!enumMember.prepare(exceptionState))
+            return;
         String string = enumMember;
         if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
             exceptionState.throwTypeError("member enumMember ('" + string + "') is not a valid enum value.");
             return;
         }
         impl.setEnumMember(enumMember);
     }
 
     v8::Local<v8::Value> eventTargetMemberValue = v8Object->Get(v8String(isolate, "eventTargetMember"));
     if (block.HasCaught()) {
@@ skipping 12 matching lines @@
     }
 
     v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
     }
 
     v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setLongMember(longMember);
     }
 
     v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
         // Do nothing.
@@ skipping 26 matching lines @@
 
     v8::Local<v8::Value> otherDoubleOrStringMemberValue = v8Object->Get(v8String(isolate, "otherDoubleOrStringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         DoubleOrString otherDoubleOrStringMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState), exceptionState);
+        V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState);
+        if (exceptionState.hadException())
+            return;
         impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
     }
 
     v8::Local<v8::Value> restrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "restrictedDoubleMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setRestrictedDoubleMember(restrictedDoubleMember);
     }
 
     v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setStringArrayMember(stringArrayMember);
     }
 
     v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
+        V8StringResource<> stringMember = stringMemberValue;
+        if (!stringMember.prepare(exceptionState))
+            return;
         impl.setStringMember(stringMember);
     }
 
     v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setStringOrNullMember(stringOrNullMember);
     }
 
     v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setStringSequenceMember(stringSequenceMember);
     }
 
     v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue = v8Object->Get(v8String(isolate, "testInterface2OrUint8ArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
         TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState), exceptionState);
+        V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState);
+        if (exceptionState.hadException())
+            return;
         impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
     }
 
     v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
         // Do nothing.
@@ skipping 109 matching lines @@
     }
 
     v8::Local<v8::Value> unrestrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "unrestrictedDoubleMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
     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;
         impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
     }
 
 }
 
 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;
@@ skipping 130 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