static void unsignedLongLongAttrAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) { ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedLongLongAttr", "TestTypedefs", info.Holder(), info.GetIsolate()); TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_EXCEPTION_VOID(unsigned long long, cppValue, toUInt64(jsValue, exceptionState), exceptionState); imp->setUnsignedLongLongAttr(cppValue); }
static void attrWithGetterExceptionAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) { ExceptionState exceptionState(ExceptionState::SetterContext, "attrWithGetterException", "TestTypedefs", info.Holder(), info.GetIsolate()); TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), exceptionState); imp->setAttrWithGetterException(cppValue); }
static void domStringOrDoubleMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder()); StringOrDouble result; impl->domStringOrDoubleMethod(result); v8SetReturnValue(info, result); }
static void testInterfaceOrTestInterfaceEmptyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder()); TestInterfaceOrTestInterfaceEmpty result; impl->testInterfaceOrTestInterfaceEmptyMethod(result); v8SetReturnValue(info, result); }
static void stringAttrWithSetterExceptionAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) { ExceptionState exceptionState(ExceptionState::SetterContext, "stringAttrWithSetterException", "TestTypedefs", info.Holder(), info.GetIsolate()); TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, jsValue); imp->setStringAttrWithSetterException(cppValue, exceptionState); exceptionState.throwIfNeeded(); }
static void methodWithExceptionMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "methodWithException", "TestTypedefs", info.Holder(), info.GetIsolate()); TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); imp->methodWithException(exceptionState); if (exceptionState.throwIfNeeded()) return; }
static void uLongLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) { v8::Handle<v8::Object> holder = info.Holder(); ExceptionState exceptionState(ExceptionState::SetterContext, "uLongLongAttribute", "TestTypedefs", holder, info.GetIsolate()); TestTypedefs* impl = V8TestTypedefs::toNative(holder); TONATIVE_VOID_EXCEPTIONSTATE(unsigned long long, cppValue, toUInt64(v8Value, exceptionState), exceptionState); impl->setULongLongAttribute(cppValue); }
static void stringAttrWithGetterExceptionAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); ExceptionState exceptionState(ExceptionState::GetterContext, "stringAttrWithGetterException", "TestTypedefs", info.Holder(), info.GetIsolate()); String jsValue = imp->stringAttrWithGetterException(exceptionState); if (UNLIKELY(exceptionState.throwIfNeeded())) return; v8SetReturnValueString(info, jsValue, info.GetIsolate()); }
static void methodWithSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwTypeError(ExceptionMessages::failedToExecute("methodWithSequenceArg", "TestTypedefs", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate()); return; } TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_VOID(Vector<RefPtr<SerializedScriptValue> >, sequenceArg, (toRefPtrNativeArray<SerializedScriptValue, V8SerializedScriptValue>(info[0], 1, info.GetIsolate()))); v8SetReturnValue(info, static_cast<double>(imp->methodWithSequenceArg(sequenceArg))); }
static void uLongLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) { v8::Local<v8::Object> holder = info.Holder(); ExceptionState exceptionState(ExceptionState::SetterContext, "uLongLongAttribute", "TestTypedefs", holder, info.GetIsolate()); TestTypedefs* impl = V8TestTypedefs::toImpl(holder); unsigned long long cppValue = toUInt64(info.GetIsolate(), v8Value, NormalConversion, exceptionState); if (exceptionState.throwIfNeeded()) return; impl->setULongLongAttribute(cppValue); }
static void funcMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); if (UNLIKELY(info.Length() <= 0)) { imp->func(); return; } V8TRYCATCH_VOID(Vector<int>, x, toNativeArray<int>(info[0], 1, info.GetIsolate())); imp->func(x); }
static void nullableArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwTypeError(ExceptionMessages::failedToExecute("nullableArrayArg", "TestTypedefs", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate()); return; } TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); bool arrayArgIsNull = info[0]->IsNull(); V8TRYCATCH_VOID(Vector<String>, arrayArg, toNativeArray<String>(info[0], 1, info.GetIsolate())); imp->nullableArrayArg(arrayArgIsNull ? 0 : &arrayArg); }
static void voidMethodTestCallbackInterfaceArgumentMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArgument", "TestTypedefs", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate()); return; } TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); if (info.Length() <= 0 || !info[0]->IsFunction()) { throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArgument", "TestTypedefs", "The callback provided as parameter 1 is not a function."), info.GetIsolate()); return; } OwnPtr<TestCallbackInterface> testCallbackInterface = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate())); imp->voidMethodTestCallbackInterfaceArgument(testCallbackInterface.release()); }
static void voidMethodArrayOfLongsArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder()); Vector<int> arrayOfLongsArg; { v8::TryCatch block; V8RethrowTryCatchScope rethrow(block); if (UNLIKELY(info.Length() <= 0)) { impl->voidMethodArrayOfLongsArg(); return; } TONATIVE_VOID_INTERNAL(arrayOfLongsArg, toNativeArray<int>(info[0], 1, info.GetIsolate())); } impl->voidMethodArrayOfLongsArg(arrayOfLongsArg); }
static void stringArrayMethodStringArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwMinimumArityTypeErrorForMethod("stringArrayMethodStringArrayArg", "TestTypedefs", 1, info.Length(), info.GetIsolate()); return; } TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder()); Vector<String> stringArrayArg; { v8::TryCatch block; V8RethrowTryCatchScope rethrow(block); TONATIVE_VOID_INTERNAL(stringArrayArg, toNativeArray<String>(info[0], 1, info.GetIsolate())); } v8SetReturnValue(info, v8Array(impl->stringArrayMethodStringArrayArg(stringArrayArg), info.Holder(), info.GetIsolate())); }
static void stringArrayFunction2Method(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringArrayFunction2", "TestTypedefs", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 1)) { exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length())); exceptionState.throwIfNeeded(); return; } TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_VOID(Vector<String>, values, toNativeArray<String>(info[0], 1, info.GetIsolate())); Vector<String> result = imp->stringArrayFunction2(values, exceptionState); if (exceptionState.throwIfNeeded()) return; v8SetReturnValue(info, v8Array(result, info.GetIsolate())); }
static void uLongLongMethodTestInterfaceEmptyTypeSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwMinimumArityTypeErrorForMethod("uLongLongMethodTestInterfaceEmptyTypeSequenceArg", "TestTypedefs", 1, info.Length(), info.GetIsolate()); return; } TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder()); Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptyTypeSequenceArg; { v8::TryCatch block; V8RethrowTryCatchScope rethrow(block); TONATIVE_VOID_INTERNAL(testInterfaceEmptyTypeSequenceArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate()))); } v8SetReturnValue(info, static_cast<double>(impl->uLongLongMethodTestInterfaceEmptyTypeSequenceArg(testInterfaceEmptyTypeSequenceArg))); }
static void voidMethodArrayOfLongsArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodArrayOfLongsArg", "TestTypedefs", info.Holder(), info.GetIsolate()); TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder()); Vector<int> arrayOfLongsArg; { if (UNLIKELY(info.Length() <= 0)) { impl->voidMethodArrayOfLongsArg(); return; } arrayOfLongsArg = toImplArray<int>(info[0], 1, info.GetIsolate(), exceptionState); if (exceptionState.throwIfNeeded()) return; } impl->voidMethodArrayOfLongsArg(arrayOfLongsArg); }
static void uLongLongMethodTestInterfaceEmptyTypeSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "uLongLongMethodTestInterfaceEmptyTypeSequenceArg", "TestTypedefs", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 1)) { setMinimumArityTypeError(exceptionState, 1, info.Length()); exceptionState.throwIfNeeded(); return; } TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder()); Vector<RefPtr<TestInterfaceEmpty>> testInterfaceEmptyTypeSequenceArg; { testInterfaceEmptyTypeSequenceArg = (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate(), exceptionState)); if (exceptionState.throwIfNeeded()) return; } v8SetReturnValue(info, static_cast<double>(impl->uLongLongMethodTestInterfaceEmptyTypeSequenceArg(testInterfaceEmptyTypeSequenceArg))); }
static void voidMethodTestCallbackInterfaceTypeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwMinimumArityTypeErrorForMethod("voidMethodTestCallbackInterfaceTypeArg", "TestTypedefs", 1, info.Length(), info.GetIsolate()); return; } TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder()); OwnPtr<TestCallbackInterface> testCallbackInterfaceTypeArg; { if (info.Length() <= 0 || !info[0]->IsFunction()) { throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceTypeArg", "TestTypedefs", "The callback provided as parameter 1 is not a function."), info.GetIsolate()); return; } testCallbackInterfaceTypeArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate())); } impl->voidMethodTestCallbackInterfaceTypeArg(testCallbackInterfaceTypeArg.release()); }
static void stringArrayMethodStringArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringArrayMethodStringArrayArg", "TestTypedefs", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 1)) { setMinimumArityTypeError(exceptionState, 1, info.Length()); exceptionState.throwIfNeeded(); return; } TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder()); Vector<String> stringArrayArg; { stringArrayArg = toImplArray<String>(info[0], 1, info.GetIsolate(), exceptionState); if (exceptionState.throwIfNeeded()) return; } v8SetReturnValue(info, toV8(impl->stringArrayMethodStringArrayArg(stringArrayArg), info.Holder(), info.GetIsolate())); }
static void voidMethodFloatArgStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 2)) { throwMinimumArityTypeErrorForMethod("voidMethodFloatArgStringArg", "TestTypedefs", 2, info.Length(), info.GetIsolate()); return; } TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder()); float floatArg; V8StringResource<> stringArg; { v8::TryCatch block; V8RethrowTryCatchScope rethrow(block); TONATIVE_VOID_INTERNAL(floatArg, static_cast<float>(info[0]->NumberValue())); TOSTRING_VOID_INTERNAL(stringArg, info[1]); } impl->voidMethodFloatArgStringArg(floatArg, stringArg); }
static void testInterfaceOrTestInterfaceEmptyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder()); bool result0Enabled = false; RefPtr<TestInterfaceImplementation> result0; bool result1Enabled = false; RefPtr<TestInterfaceEmpty> result1; impl->testInterfaceOrTestInterfaceEmptyMethod(result0Enabled, result0, result1Enabled, result1); if (result0Enabled) { v8SetReturnValue(info, result0.release()); return; } if (result1Enabled) { v8SetReturnValue(info, result1.release()); return; } v8SetReturnValueNull(info); }
static void voidMethodFloatArgStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodFloatArgStringArg", "TestTypedefs", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 2)) { setMinimumArityTypeError(exceptionState, 2, info.Length()); exceptionState.throwIfNeeded(); return; } TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder()); float floatArg; V8StringResource<> stringArg; { floatArg = toRestrictedFloat(info.GetIsolate(), info[0], exceptionState); if (exceptionState.throwIfNeeded()) return; stringArg = info[1]; if (!stringArg.prepare()) return; } impl->voidMethodFloatArgStringArg(floatArg, stringArg); }
static void setShadowMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 3)) { throwTypeError(ExceptionMessages::failedToExecute("setShadow", "TestTypedefs", ExceptionMessages::notEnoughArguments(3, info.Length())), info.GetIsolate()); return; } TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_VOID(float, width, static_cast<float>(info[0]->NumberValue())); V8TRYCATCH_VOID(float, height, static_cast<float>(info[1]->NumberValue())); V8TRYCATCH_VOID(float, blur, static_cast<float>(info[2]->NumberValue())); if (UNLIKELY(info.Length() <= 3)) { imp->setShadow(width, height, blur); return; } V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, color, info[3]); if (UNLIKELY(info.Length() <= 4)) { imp->setShadow(width, height, blur, color); return; } V8TRYCATCH_VOID(float, alpha, static_cast<float>(info[4]->NumberValue())); imp->setShadow(width, height, blur, color, alpha); }
static void unsignedLongLongAttrAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_VOID(unsigned long long, cppValue, toUInt64(jsValue)); imp->setUnsignedLongLongAttr(cppValue); }
static void unsignedLongLongAttrAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); v8SetReturnValue(info, static_cast<double>(imp->unsignedLongLongAttr())); }
static void immutablePointFunctionMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); v8SetReturnValue(info, WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(imp->immutablePointFunction()))); }
static void stringAttrWithSetterExceptionAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); v8SetReturnValueString(info, imp->stringAttrWithSetterException(), info.GetIsolate()); }
static void stringAttrWithGetterExceptionAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, jsValue); imp->setStringAttrWithGetterException(cppValue); }