void V8MutationCallback::call(const WillBeHeapVector<RefPtrWillBeMember<MutationRecord> >& mutations, MutationObserver* observer)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
if (m_callback.isEmpty())
return;
v8::Handle<v8::Value> observerHandle = toV8(observer, m_scriptState->context()->Global(), isolate);
if (observerHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
if (!observerHandle->IsObject())
return;
v8::Handle<v8::Object> thisObject = v8::Handle<v8::Object>::Cast(observerHandle);
v8::Handle<v8::Value> argv[] = { v8Array(mutations, m_scriptState->context()->Global(), isolate), observerHandle };
v8::TryCatch exceptionCatcher;
exceptionCatcher.SetVerbose(true);
ScriptController::callFunction(executionContext(), m_callback.newLocal(isolate), thisObject, WTF_ARRAY_LENGTH(argv), argv, isolate);
}
void V8MutationCallback::call(const Vector<RefPtr<MutationRecord> >& mutations, MutationObserver* observer)
{
if (!canInvokeCallback())
return;
v8::HandleScope handleScope(m_isolate);
v8::Handle<v8::Context> v8Context = toV8Context(executionContext(), m_world.get());
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Function> callback = m_callback.newLocal(m_isolate);
if (callback.IsEmpty())
return;
v8::Handle<v8::Value> observerHandle = toV8(observer, v8::Handle<v8::Object>(), m_isolate);
if (observerHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
if (!observerHandle->IsObject())
return;
v8::Handle<v8::Object> thisObject = v8::Handle<v8::Object>::Cast(observerHandle);
v8::Handle<v8::Value> argv[] = { v8Array(mutations, m_isolate), observerHandle };
v8::TryCatch exceptionCatcher;
exceptionCatcher.SetVerbose(true);
ScriptController::callFunction(executionContext(), callback, thisObject, 2, argv, m_isolate);
}
bool V8TestCallback::callbackWithSequence(Vector<RefPtr<TestObj> > sequenceParam)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_world.get());
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> sequenceParamHandle = v8Array(sequenceParam, v8Context->GetIsolate());
if (sequenceParamHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
sequenceParamHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 1, argv, callbackReturnValue, scriptExecutionContext());
}
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 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()));
}
void V8TestCallbackInterface::voidMethodSequenceArg(const Vector<RefPtr<TestInterfaceEmpty> >& sequenceArg)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsEmpty())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Handle<v8::Value> sequenceArgHandle = v8Array(sequenceArg, isolate);
if (sequenceArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { sequenceArgHandle };
invokeCallback(m_callback.newLocal(isolate), 1, argv, executionContext(), isolate);
}
void V8TestCallbackInterface::voidMethodWillBeGarbageCollectedArrayArg(const WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> >& arrayArg)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsEmpty())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Handle<v8::Value> arrayArgHandle = v8Array(arrayArg, isolate);
if (arrayArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { arrayArgHandle };
invokeCallback(m_callback.newLocal(isolate), 1, argv, executionContext(), isolate);
}
void V8TestCallbackInterface::voidMethodSequenceArg(const Vector<RefPtr<TestInterfaceEmpty> >& sequenceArg)
{
if (!canInvokeCallback())
return;
v8::HandleScope handleScope(m_isolate);
v8::Handle<v8::Context> v8Context = toV8Context(executionContext(), m_world.get());
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> sequenceArgHandle = v8Array(sequenceArg, m_isolate);
if (sequenceArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { sequenceArgHandle };
invokeCallback(m_callback.newLocal(m_isolate), 1, argv, executionContext(), m_isolate);
}
void V8TestCallbackInterface::voidMethodWillBeGarbageCollectedArrayArg(const WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> >& arrayArg)
{
if (!canInvokeCallback())
return;
v8::HandleScope handleScope(m_isolate);
v8::Handle<v8::Context> v8Context = toV8Context(executionContext(), m_world.get());
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> arrayArgHandle = v8Array(arrayArg, m_isolate);
if (arrayArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { arrayArgHandle };
invokeCallback(m_callback.newLocal(m_isolate), 1, argv, executionContext(), m_isolate);
}
bool V8TestCallback::callbackWithSequenceArg(const Vector<RefPtr<TestInterfaceEmpty> >& sequenceArg)
{
if (!canInvokeCallback())
return true;
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Context> v8Context = toV8Context(executionContext(), m_world.get());
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> sequenceArgHandle = v8Array(sequenceArg, isolate);
if (sequenceArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = { sequenceArgHandle };
bool callbackReturnValue = false;
return !invokeCallback(m_callback.newLocal(isolate), 1, argv, callbackReturnValue, executionContext(), isolate);
}
v8::Handle<v8::Value> toV8(TestDictionary& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
v8::Handle<v8::Object> v8Object = v8::Object::New(isolate);
if (impl.hasBooleanMember()) {
v8Object->Set(v8String(isolate, "booleanMember"), v8Boolean(impl.booleanMember(), isolate));
}
if (impl.hasCreateMember()) {
v8Object->Set(v8String(isolate, "create"), v8Boolean(impl.createMember(), isolate));
}
if (impl.hasDoubleOrNullMember()) {
v8Object->Set(v8String(isolate, "doubleOrNullMember"), v8::Number::New(isolate, impl.doubleOrNullMember()));
} else {
v8Object->Set(v8String(isolate, "doubleOrNullMember"), v8::Null(isolate));
}
if (impl.hasElementOrNullMember()) {
v8Object->Set(v8String(isolate, "elementOrNullMember"), toV8(impl.elementOrNullMember(), creationContext, isolate));
}
if (impl.hasEnumMember()) {
v8Object->Set(v8String(isolate, "enumMember"), v8String(isolate, impl.enumMember()));
} else {
v8Object->Set(v8String(isolate, "enumMember"), v8String(isolate, String("foo")));
}
if (impl.hasLongMember()) {
v8Object->Set(v8String(isolate, "longMember"), v8::Integer::New(isolate, impl.longMember()));
} else {
v8Object->Set(v8String(isolate, "longMember"), v8::Integer::New(isolate, 1));
}
if (impl.hasObjectMember()) {
ASSERT(impl.objectMember().isObject());
v8Object->Set(v8String(isolate, "objectMember"), impl.objectMember().v8Value());
}
if (impl.hasObjectOrNullMember()) {
ASSERT(impl.objectOrNullMember().isObject());
v8Object->Set(v8String(isolate, "objectOrNullMember"), impl.objectOrNullMember().v8Value());
}
if (impl.hasStringArrayMember()) {
v8Object->Set(v8String(isolate, "stringArrayMember"), v8Array(impl.stringArrayMember(), creationContext, isolate));
}
if (impl.hasStringMember()) {
v8Object->Set(v8String(isolate, "stringMember"), v8String(isolate, impl.stringMember()));
}
if (impl.hasStringOrNullMember()) {
v8Object->Set(v8String(isolate, "stringOrNullMember"), v8String(isolate, impl.stringOrNullMember()));
} else {
v8Object->Set(v8String(isolate, "stringOrNullMember"), v8String(isolate, String("default string value")));
}
if (impl.hasStringSequenceMember()) {
v8Object->Set(v8String(isolate, "stringSequenceMember"), v8Array(impl.stringSequenceMember(), creationContext, isolate));
}
if (impl.hasTestInterfaceGarbageCollectedMember()) {
v8Object->Set(v8String(isolate, "testInterfaceGarbageCollectedMember"), toV8(impl.testInterfaceGarbageCollectedMember(), creationContext, isolate));
}
if (impl.hasTestInterfaceGarbageCollectedOrNullMember()) {
v8Object->Set(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"), toV8(impl.testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate));
}
if (impl.hasTestInterfaceMember()) {
v8Object->Set(v8String(isolate, "testInterfaceMember"), toV8(impl.testInterfaceMember(), creationContext, isolate));
}
if (impl.hasTestInterfaceOrNullMember()) {
v8Object->Set(v8String(isolate, "testInterfaceOrNullMember"), toV8(impl.testInterfaceOrNullMember(), creationContext, isolate));
}
if (impl.hasTestInterfaceWillBeGarbageCollectedMember()) {
v8Object->Set(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"), toV8(impl.testInterfaceWillBeGarbageCollectedMember(), creationContext, isolate));
}
if (impl.hasTestInterfaceWillBeGarbageCollectedOrNullMember()) {
v8Object->Set(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"), toV8(impl.testInterfaceWillBeGarbageCollectedOrNullMember(), creationContext, isolate));
}
return v8Object;
}
static v8::Handle<v8::Value> buttonsAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
Gamepad* imp = V8Gamepad::toNative(info.Holder());
return v8Array(imp->buttons(), info.GetIsolate());
}
