void V8TestCallbackInterface::callbackWithThisValueVoidMethodStringArg(ScriptValue thisValue, 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> thisHandle = thisValue.v8Value();
if (thisHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
ASSERT(thisHandle->IsObject());
v8::Handle<v8::Value> stringArgHandle = v8String(m_isolate, stringArg);
if (stringArgHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return;
}
v8::Handle<v8::Value> argv[] = { stringArgHandle };
invokeCallback(m_callback.newLocal(m_isolate), v8::Handle<v8::Object>::Cast(thisHandle), 1, argv, executionContext(), m_isolate);
}
ScriptPreprocessor::ScriptPreprocessor(const ScriptSourceCode& preprocessorSourceCode, Frame* frame)
: m_isolate(V8PerIsolateData::mainThreadIsolate())
, m_isPreprocessing(false)
{
ASSERT(frame);
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
Vector<ScriptSourceCode> sources;
sources.append(preprocessorSourceCode);
Vector<ScriptValue> scriptResults;
frame->script().executeScriptInIsolatedWorld(ScriptPreprocessorIsolatedWorldId, sources, DOMWrapperWorld::mainWorldExtensionGroup, &scriptResults);
if (scriptResults.size() != 1) {
frame->host()->console().addMessage(JSMessageSource, ErrorMessageLevel, "ScriptPreprocessor internal error, one ScriptSourceCode must give exactly one result.");
return;
}
ScriptValue preprocessorFunction = scriptResults[0];
if (!preprocessorFunction.isFunction()) {
frame->host()->console().addMessage(JSMessageSource, ErrorMessageLevel, "The preprocessor must compile to a function.");
return;
}
m_world = DOMWrapperWorld::ensureIsolatedWorld(ScriptPreprocessorIsolatedWorldId, DOMWrapperWorld::mainWorldExtensionGroup);
v8::Local<v8::Context> context = toV8Context(m_isolate, frame, m_world.get());
m_context.set(m_isolate, context);
m_preprocessorFunction.set(m_isolate, v8::Handle<v8::Function>::Cast(preprocessorFunction.v8Value()));
}
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 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 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());
}
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 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());
}
ScriptPreprocessor::ScriptPreprocessor(const ScriptSourceCode& preprocessorSourceCode, LocalFrame* frame)
: m_isPreprocessing(false)
{
RefPtr<DOMWrapperWorld> world = DOMWrapperWorld::ensureIsolatedWorld(ScriptPreprocessorIsolatedWorldId, DOMWrapperWorld::mainWorldExtensionGroup);
m_scriptState = ScriptState::from(toV8Context(frame, *world));
v8::HandleScope handleScope(m_scriptState->isolate());
ASSERT(frame);
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
Vector<ScriptSourceCode> sources;
sources.append(preprocessorSourceCode);
Vector<v8::Local<v8::Value> > scriptResults;
frame->script().executeScriptInIsolatedWorld(ScriptPreprocessorIsolatedWorldId, sources, DOMWrapperWorld::mainWorldExtensionGroup, &scriptResults);
if (scriptResults.size() != 1) {
frame->console().addMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, "ScriptPreprocessor internal error, one ScriptSourceCode must give exactly one result."));
return;
}
v8::Local<v8::Value> preprocessorFunction = scriptResults[0];
if (preprocessorFunction.IsEmpty() || !preprocessorFunction->IsFunction()) {
frame->console().addMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, "The preprocessor must compile to a function."));
return;
}
m_preprocessorFunction.set(m_scriptState->isolate(), v8::Handle<v8::Function>::Cast(preprocessorFunction));
}
bool eventListenerHandlerLocation(Document* document, EventListener* listener, String& sourceName, String& scriptId, int& lineNumber)
{
if (listener->type() != EventListener::JSEventListenerType)
return false;
v8::HandleScope scope(toIsolate(document));
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener);
v8::Handle<v8::Context> context = toV8Context(document, v8Listener->world());
v8::Context::Scope contextScope(context);
v8::Local<v8::Object> object = v8Listener->getListenerObject(document);
if (object.IsEmpty())
return false;
v8::Handle<v8::Function> function = eventListenerEffectiveFunction(scope.GetIsolate(), object);
if (function.IsEmpty())
return false;
v8::Handle<v8::Function> originalFunction = getBoundFunction(function);
int scriptIdValue = originalFunction->ScriptId();
scriptId = String::number(scriptIdValue);
v8::ScriptOrigin origin = originalFunction->GetScriptOrigin();
if (!origin.ResourceName().IsEmpty() && origin.ResourceName()->IsString())
sourceName = toCoreString(origin.ResourceName().As<v8::String>());
else
sourceName = "";
lineNumber = originalFunction->GetScriptLineNumber();
return true;
}
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);
}
void V8Window::eventAttributeGetterCustom(
const v8::PropertyCallbackInfo<v8::Value>& info) {
LocalDOMWindow* impl = toLocalDOMWindow(V8Window::toImpl(info.Holder()));
ExceptionState exceptionState(ExceptionState::GetterContext, "event",
"Window", info.Holder(), info.GetIsolate());
if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()),
impl, exceptionState)) {
return;
}
LocalFrame* frame = impl->frame();
ASSERT(frame);
// This is a fast path to retrieve info.Holder()->CreationContext().
v8::Local<v8::Context> context =
toV8Context(frame, DOMWrapperWorld::current(info.GetIsolate()));
if (context.IsEmpty())
return;
v8::Local<v8::Value> jsEvent = V8HiddenValue::getHiddenValue(
ScriptState::current(info.GetIsolate()), context->Global(),
V8HiddenValue::event(info.GetIsolate()));
if (jsEvent.IsEmpty())
return;
v8SetReturnValue(info, jsEvent);
}
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::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 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 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;
}
PassRefPtr<ScriptPromiseResolver> ScriptPromiseResolver::create(ScriptExecutionContext* context)
{
ASSERT(v8::Context::InContext());
ASSERT(context);
v8::Isolate* isolate = v8::Isolate::GetCurrent();
return adoptRef(new ScriptPromiseResolver(toV8Context(context, DOMWrapperWorld::current())->Global(), isolate));
}
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());
}
void V8AbstractEventListener::handleEvent(ScriptExecutionContext* context, Event* event)
{
// Don't reenter V8 if execution was terminated in this instance of V8.
if (context->isJSExecutionForbidden())
return;
ASSERT(event);
// The callback function on XMLHttpRequest can clear the event listener and destroys 'this' object. Keep a local reference to it.
// See issue 889829.
RefPtr<V8AbstractEventListener> protect(this);
v8::HandleScope handleScope;
v8::Local<v8::Context> v8Context = toV8Context(context, worldContext());
if (v8Context.IsEmpty())
return;
// Enter the V8 context in which to perform the event handling.
v8::Context::Scope scope(v8Context);
// Get the V8 wrapper for the event object.
v8::Handle<v8::Value> jsEvent = toV8(event);
ASSERT(!jsEvent.IsEmpty());
invokeEventHandler(context, event, jsEvent);
}
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());
}
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 IDBRequest::onSuccess(PassRefPtr<IDBCursorBackendInterface> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SerializedScriptValue> serializedValue)
{
IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
if (!shouldEnqueueEvent())
return;
#if USE(V8)
v8::HandleScope handleScope;
v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
if (context.IsEmpty())
CRASH();
v8::Context::Scope contextScope(context);
#endif
ScriptValue value = deserializeIDBValue(scriptExecutionContext(), serializedValue);
ASSERT(m_cursorType != IDBCursorBackendInterface::InvalidCursorType);
RefPtr<IDBCursor> cursor;
if (m_cursorType == IDBCursorBackendInterface::IndexKeyCursor)
cursor = IDBCursor::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
else
cursor = IDBCursorWithValue::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
setResultCursor(cursor, key, primaryKey, value);
enqueueEvent(createSuccessEvent());
}
void IDBRequest::onSuccess(PassRefPtr<SerializedScriptValue> prpSerializedScriptValue, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
{
IDB_TRACE("IDBRequest::onSuccess(SerializedScriptValue, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
#if USE(V8)
v8::HandleScope handleScope;
v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
if (context.IsEmpty())
CRASH();
v8::Context::Scope contextScope(context);
#endif
#ifndef NDEBUG
ASSERT(keyPath == effectiveObjectStore(m_source)->keyPath());
#endif
ScriptValue value = deserializeIDBValue(scriptExecutionContext(), prpSerializedScriptValue);
RefPtr<IDBKey> primaryKey = prpPrimaryKey;
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(value, keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(primaryKey.get()));
#endif
bool injected = injectIDBKeyIntoScriptValue(primaryKey, value, keyPath);
ASSERT_UNUSED(injected, injected);
onSuccessInternal(value);
}
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 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);
}
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());
}
static v8::Handle<v8::Array> getJSListenerFunctions(Document* document, const EventListenerInfo& listenerInfo)
{
v8::Local<v8::Array> result = v8::Array::New();
size_t handlersCount = listenerInfo.eventListenerVector.size();
for (size_t i = 0, outputIndex = 0; i < handlersCount; ++i) {
RefPtr<EventListener> listener = listenerInfo.eventListenerVector[i].listener;
if (listener->type() != EventListener::JSEventListenerType) {
ASSERT_NOT_REACHED();
continue;
}
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener.get());
v8::Local<v8::Context> context = toV8Context(document, v8Listener->world());
// Hide listeners from other contexts.
if (context != v8::Context::GetCurrent())
continue;
v8::Local<v8::Object> function;
{
// getListenerObject() may cause JS in the event attribute to get compiled, potentially unsuccessfully.
v8::TryCatch block;
function = v8Listener->getListenerObject(document);
if (block.HasCaught())
continue;
}
ASSERT(!function.IsEmpty());
v8::Local<v8::Object> listenerEntry = v8::Object::New();
listenerEntry->Set(v8::String::NewSymbol("listener"), function);
listenerEntry->Set(v8::String::NewSymbol("useCapture"), v8::Boolean::New(listenerInfo.eventListenerVector[i].useCapture));
result->Set(v8::Number::New(outputIndex++), listenerEntry);
}
return result;
}
void V8AbstractEventListener::invokeEventHandler(ExecutionContext* context, Event* event, v8::Local<v8::Value> jsEvent)
{
// If jsEvent is empty, attempt to set it as a hidden value would crash v8.
if (jsEvent.IsEmpty())
return;
v8::Local<v8::Context> v8Context = toV8Context(context, world());
if (v8Context.IsEmpty())
return;
// We push the event being processed into the global object, so that it can be exposed by DOMWindow's bindings.
v8::Handle<v8::String> eventSymbol = v8AtomicString(v8Context->GetIsolate(), "event");
v8::Local<v8::Value> returnValue;
{
// Catch exceptions thrown in the event handler so they do not propagate to javascript code that caused the event to fire.
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
// Save the old 'event' property so we can restore it later.
v8::Local<v8::Value> savedEvent = getHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol);
tryCatch.Reset();
// Make the event available in the global object, so DOMWindow can expose it.
setHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol, jsEvent);
tryCatch.Reset();
returnValue = callListenerFunction(context, jsEvent, event);
if (tryCatch.HasCaught())
event->target()->uncaughtExceptionInEventHandler();
if (!tryCatch.CanContinue()) { // Result of TerminateExecution().
if (context->isWorkerGlobalScope())
toWorkerGlobalScope(context)->script()->forbidExecution();
return;
}
tryCatch.Reset();
// Restore the old event. This must be done for all exit paths through this method.
if (savedEvent.IsEmpty())
setHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol, v8::Undefined(v8Context->GetIsolate()));
else
setHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol, savedEvent);
tryCatch.Reset();
}
ASSERT(!handleOutOfMemory() || returnValue.IsEmpty());
if (returnValue.IsEmpty())
return;
if (!returnValue->IsNull() && !returnValue->IsUndefined() && event->isBeforeUnloadEvent()) {
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringReturnValue, returnValue);
toBeforeUnloadEvent(event)->setReturnValue(stringReturnValue);
}
if (m_isAttribute && shouldPreventDefault(returnValue))
event->preventDefault();
}
static v8::Local<v8::Context> mainWorldContext(v8::Isolate* isolate, NPP npp, NPObject* npObject)
{
ASSERT(npObject->_class == &V8NPObjectClass);
V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
DOMWindow* window = object->rootObject;
if (!window || !window->isCurrentlyDisplayedInFrame())
return v8::Local<v8::Context>();
return toV8Context(isolate, object->rootObject->frame(), DOMWrapperWorld::mainWorld());
}
ScriptPromise ScriptPromise::createPending(ExecutionContext* context)
{
ASSERT(context);
v8::Isolate* isolate = toIsolate(context);
ASSERT(isolate->InContext());
v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current());
v8::Handle<v8::Object> creationContext = v8Context.IsEmpty() ? v8::Object::New(isolate) : v8Context->Global();
v8::Handle<v8::Object> promise = V8PromiseCustom::createPromise(creationContext, isolate);
return ScriptPromise(promise, isolate);
}
