void V8TestCallbackInterface::voidMethodTestInterfaceEmptyStringArg(TestInterfaceEmpty* testInterfaceEmptyArg, const String& stringArg)
{
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> testInterfaceEmptyArgHandle = toV8(testInterfaceEmptyArg, v8::Handle<v8::Object>(), m_isolate);
if (testInterfaceEmptyArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> stringArgHandle = v8String(m_isolate, stringArg);
if (stringArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { testInterfaceEmptyArgHandle, stringArgHandle };
invokeCallback(m_callback.newLocal(m_isolate), 2, argv, executionContext(), m_isolate);
}
bool JSMutationCallback::handleEvent(MutationRecordArray* mutations, WebKitMutationObserver* observer)
{
if (!canInvokeCallback())
return true;
RefPtr<JSMutationCallback> protect(this);
JSLock lock(SilenceAssertionsOnly);
ExecState* exec = m_data->globalObject()->globalExec();
MarkedArgumentBuffer mutationList;
for (size_t i = 0; i < mutations->size(); ++i)
mutationList.append(toJS(exec, m_data->globalObject(), mutations->at(i).get()));
JSValue jsObserver = toJS(exec, m_data->globalObject(), observer);
MarkedArgumentBuffer args;
args.append(constructArray(exec, m_data->globalObject(), mutationList));
args.append(jsObserver);
bool raisedException = false;
m_data->invokeCallback(jsObserver, args, &raisedException);
return !raisedException;
}
void V8CustomElementLifecycleCallbacks::attributeChanged(Element* element, const AtomicString& name, const AtomicString& oldValue, const AtomicString& newValue)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = toIsolate(scriptExecutionContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Context> context = toV8Context(scriptExecutionContext(), m_world.get());
if (context.IsEmpty())
return;
v8::Context::Scope scope(context);
v8::Handle<v8::Object> receiver = toV8(element, context->Global(), isolate).As<v8::Object>();
ASSERT(!receiver.IsEmpty());
v8::Handle<v8::Function> callback = m_attributeChanged.newLocal(isolate);
if (callback.IsEmpty())
return;
v8::Handle<v8::Value> argv[] = {
v8String(name, isolate),
oldValue.isNull() ? v8::Handle<v8::Value>(v8::Null(isolate)) : v8::Handle<v8::Value>(v8String(oldValue, isolate)),
newValue.isNull() ? v8::Handle<v8::Value>(v8::Null(isolate)) : v8::Handle<v8::Value>(v8String(newValue, isolate))
};
v8::TryCatch exceptionCatcher;
exceptionCatcher.SetVerbose(true);
ScriptController::callFunctionWithInstrumentation(scriptExecutionContext(), callback, receiver, WTF_ARRAY_LENGTH(argv), argv, isolate);
}
bool V8NavigatorUserMediaSuccessCallback::handleEvent(LocalMediaStream* stream)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> streamHandle = toV8(stream);
if (streamHandle.IsEmpty()) {
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
streamHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback, 1, argv, callbackReturnValue, scriptExecutionContext());
}
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());
}
bool V8TestCallback::callbackWithTestObjectParam(TestObj* class2Param, const String& strArg)
{
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> class2ParamHandle = toV8(class2Param, v8::Handle<v8::Object>(), v8Context->GetIsolate());
if (class2ParamHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> strArgHandle = v8String(strArg, v8Context->GetIsolate());
if (strArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
class2ParamHandle,
strArgHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 2, argv, callbackReturnValue, scriptExecutionContext());
}
bool V8TestCallback::callbackWithStringList(RefPtr<DOMStringList> listParam)
{
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> listParamHandle = toV8(listParam, v8::Handle<v8::Object>(), v8Context->GetIsolate());
if (listParamHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
listParamHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 1, argv, callbackReturnValue, scriptExecutionContext());
}
bool V8SQLStatementErrorCallback::handleEvent(SQLTransaction* transaction, SQLError* error)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> transactionHandle = toV8(transaction);
v8::Handle<v8::Value> errorHandle = toV8(error);
if (transactionHandle.IsEmpty() || errorHandle.IsEmpty()) {
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
transactionHandle,
errorHandle
};
bool callbackReturnValue = false;
// Step 6: If the error callback returns false, then move on to the next
// statement, if any, or onto the next overall step otherwise. Otherwise,
// the error callback did not return false, or there was no error callback.
// Jump to the last step in the overall steps.
return invokeCallback(m_callback, 2, argv, callbackReturnValue, scriptExecutionContext()) || callbackReturnValue;
}
bool V8AudioBufferCallback::handleEvent(AudioBuffer* audioBuffer)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> audioBufferHandle = toV8(audioBuffer);
if (audioBufferHandle.IsEmpty()) {
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
audioBufferHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback, 1, argv, callbackReturnValue, scriptExecutionContext());
}
bool V8RTCErrorCallback::handleEvent(const String& errorInformation)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> errorInformationHandle = deprecatedV8String(errorInformation);
if (errorInformationHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
errorInformationHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 1, argv, callbackReturnValue, scriptExecutionContext());
}
bool V8PositionErrorCallback::handleEvent(PositionError* error)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> errorHandle = toV8(error);
if (errorHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
errorHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 1, argv, callbackReturnValue, scriptExecutionContext());
}
void V8TestCallbackInterface::voidMethodTestInterfaceEmptyStringArg(TestInterfaceEmpty* testInterfaceEmptyArg, const String& stringArg)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsEmpty())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Handle<v8::Value> testInterfaceEmptyArgHandle = toV8(testInterfaceEmptyArg, v8::Handle<v8::Object>(), isolate);
if (testInterfaceEmptyArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> stringArgHandle = v8String(isolate, stringArg);
if (stringArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { testInterfaceEmptyArgHandle, stringArgHandle };
invokeCallback(m_callback.newLocal(isolate), 2, argv, executionContext(), isolate);
}
bool V8TestCallback::callbackWithThisArg(ScriptValue thisValue, int arg)
{
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> thisHandle = thisValue.v8Value();
if (thisHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
ASSERT(thisHandle->IsObject());
v8::Handle<v8::Value> argHandle = v8::Integer::New(arg, isolate);
if (argHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = { argHandle };
bool callbackReturnValue = false;
return !invokeCallback(m_callback.newLocal(isolate), v8::Handle<v8::Object>::Cast(thisHandle), 1, argv, callbackReturnValue, executionContext(), isolate);
}
void V8TestCallbackInterface::callbackWithThisValueVoidMethodStringArg(ScriptValue thisValue, const String& stringArg)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsEmpty())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Handle<v8::Value> thisHandle = thisValue.v8Value();
if (thisHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
ASSERT(thisHandle->IsObject());
v8::Handle<v8::Value> stringArgHandle = v8String(isolate, stringArg);
if (stringArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { stringArgHandle };
invokeCallback(m_callback.newLocal(isolate), v8::Handle<v8::Object>::Cast(thisHandle), 1, argv, executionContext(), isolate);
}
bool V8TestCallback::callbackWithTestInterfaceEmptyArg(TestInterfaceEmpty* class2Arg, const String& strArg)
{
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> class2ArgHandle = toV8(class2Arg, v8::Handle<v8::Object>(), isolate);
if (class2ArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> strArgHandle = v8String(strArg, isolate);
if (strArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = { class2ArgHandle, strArgHandle };
bool callbackReturnValue = false;
return !invokeCallback(m_callback.newLocal(isolate), 2, argv, callbackReturnValue, executionContext(), isolate);
}
bool V8SQLStatementErrorCallback::handleEvent(SQLTransaction* transaction, SQLError* error)
{
if (!canInvokeCallback())
return true;
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_world.get());
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> transactionHandle = toV8(transaction, v8::Handle<v8::Object>(), v8Context->GetIsolate());
v8::Handle<v8::Value> errorHandle = toV8(error, v8::Handle<v8::Object>(), isolate);
if (transactionHandle.IsEmpty() || errorHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
transactionHandle,
errorHandle
};
bool callbackReturnValue = false;
// Step 6: If the error callback returns false, then move on to the next
// statement, if any, or onto the next overall step otherwise. Otherwise,
// the error callback did not return false, or there was no error callback.
// Jump to the last step in the overall steps.
return invokeCallback(m_callback.newLocal(isolate), 2, argv, callbackReturnValue, scriptExecutionContext(), isolate) || callbackReturnValue;
}
bool V8SQLStatementCallback::handleEvent(SQLTransaction* transaction, SQLResultSet* resultSet)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> transactionHandle = toV8(transaction);
if (transactionHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> resultSetHandle = toV8(resultSet);
if (resultSetHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
transactionHandle,
resultSetHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 2, argv, callbackReturnValue, scriptExecutionContext());
}
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);
}
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);
}
bool V8MetadataCallback::handleEvent(Metadata* metadata)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> metadataHandle = toV8(metadata);
if (metadataHandle.IsEmpty()) {
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
metadataHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback, 1, argv, callbackReturnValue, scriptExecutionContext());
}
bool V8SQLTransactionSyncCallback::handleEvent(SQLTransactionSync* transaction)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> transactionHandle = toV8(transaction);
if (transactionHandle.IsEmpty()) {
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
transactionHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback, 1, argv, callbackReturnValue, scriptExecutionContext());
}
Microtask::Result ActiveDOMCallbackMicrotask::run()
{
if (!canInvokeCallback())
return Result::KeepInQueue;
m_task();
return Result::Done;
}
void V8TestCallbackInterface::voidMethod()
{
if (!canInvokeCallback())
return;
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> *argv = 0;
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), v8::Undefined(m_scriptState->isolate()), 0, argv, m_scriptState->isolate());
}
bool V8TestCallbackInterface::booleanMethod()
{
if (!canInvokeCallback())
return true;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsEmpty())
return true;
ScriptState::Scope scope(m_scriptState.get());
v8::Handle<v8::Value> *argv = 0;
return invokeCallback(m_callback.newLocal(isolate), 0, argv, executionContext(), isolate);
}
void V8TestCallbackInterface::voidMethodFloatArg(float floatArg)
{
if (!canInvokeCallback())
return;
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> floatArgHandle = v8::Number::New(m_scriptState->isolate(), floatArg);
v8::Local<v8::Value> argv[] = { floatArgHandle };
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), v8::Undefined(m_scriptState->isolate()), 1, argv, m_scriptState->isolate());
}
void V8TestCallbackInterface::voidMethodSequenceArg(const HeapVector<Member<TestInterfaceEmpty>>& sequenceArg)
{
if (!canInvokeCallback())
return;
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> sequenceArgHandle = toV8(sequenceArg, m_scriptState->context()->Global(), m_scriptState->isolate());
v8::Local<v8::Value> argv[] = { sequenceArgHandle };
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), v8::Undefined(m_scriptState->isolate()), 1, argv, m_scriptState->isolate());
}
void V8TestCallbackInterface::voidMethod()
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = m_scriptState->isolate();
if (m_scriptState->contextIsEmpty())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Handle<v8::Value> *argv = 0;
ScriptController::callFunction(m_scriptState->executionContext(), m_callback.newLocal(isolate), m_scriptState->context()->Global(), 0, argv, m_scriptState->isolate());
}
void V8TestCallbackInterface::voidMethodTestInterfaceEmptyStringArg(TestInterfaceEmpty* testInterfaceEmptyArg, const String& stringArg)
{
if (!canInvokeCallback())
return;
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> testInterfaceEmptyArgHandle = toV8(testInterfaceEmptyArg, m_scriptState->context()->Global(), m_scriptState->isolate());
v8::Local<v8::Value> stringArgHandle = v8String(m_scriptState->isolate(), stringArg);
v8::Local<v8::Value> argv[] = { testInterfaceEmptyArgHandle, stringArgHandle };
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), v8::Undefined(m_scriptState->isolate()), 2, argv, m_scriptState->isolate());
}
void V8TestCallbackInterface::callbackWithThisValueVoidMethodStringArg(ScriptValue thisValue, const String& stringArg)
{
if (!canInvokeCallback())
return;
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> thisHandle = thisValue.v8Value();
v8::Local<v8::Value> stringArgHandle = v8String(m_scriptState->isolate(), stringArg);
v8::Local<v8::Value> argv[] = { stringArgHandle };
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), thisHandle, 1, argv, m_scriptState->isolate());
}
bool V8TestCallbackInterface::booleanMethod()
{
if (!canInvokeCallback())
return true;
if (!m_scriptState->contextIsValid())
return true;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> *argv = 0;
v8::TryCatch exceptionCatcher(m_scriptState->isolate());
exceptionCatcher.SetVerbose(true);
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), v8::Undefined(m_scriptState->isolate()), 0, argv, m_scriptState->isolate());
return !exceptionCatcher.HasCaught();
}
