static void messageHandlerInMainThread(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
{
ASSERT(isMainThread());
v8::Isolate* isolate = v8::Isolate::GetCurrent();
// If called during context initialization, there will be no entered window.
LocalDOMWindow* enteredWindow = enteredDOMWindow(isolate);
if (!enteredWindow || !enteredWindow->isCurrentlyDisplayedInFrame())
return;
int scriptId = 0;
RefPtrWillBeRawPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
String resourceName = extractResourceName(message, enteredWindow->document());
AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
if (message->IsOpaque())
accessControlStatus = OpaqueResource;
else if (message->IsSharedCrossOrigin())
accessControlStatus = SharableCrossOrigin;
ScriptState* scriptState = ScriptState::current(isolate);
String errorMessage = toCoreStringWithNullCheck(message->Get());
int lineNumber = 0;
int columnNumber = 0;
if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
&& v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
++columnNumber;
RefPtrWillBeRawPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, resourceName, lineNumber, columnNumber, &scriptState->world());
String messageForConsole = extractMessageForConsole(isolate, data);
if (!messageForConsole.isEmpty())
event->setUnsanitizedMessage("Uncaught " + messageForConsole);
// This method might be called while we're creating a new context. In this case, we
// avoid storing the exception object, as we can't create a wrapper during context creation.
// FIXME: Can we even get here during initialization now that we bail out when GetEntered returns an empty handle?
LocalFrame* frame = enteredWindow->document()->frame();
if (frame && frame->script().existingWindowProxy(scriptState->world())) {
V8ErrorHandler::storeExceptionOnErrorEventWrapper(isolate, event.get(), data, scriptState->context()->Global());
}
if (scriptState->world().isPrivateScriptIsolatedWorld()) {
// We allow a private script to dispatch error events even in a EventDispatchForbiddenScope scope.
// Without having this ability, it's hard to debug the private script because syntax errors
// in the private script are not reported to console (the private script just crashes silently).
// Allowing error events in private scripts is safe because error events don't propagate to
// other isolated worlds (which means that the error events won't fire any event listeners
// in user's scripts).
EventDispatchForbiddenScope::AllowUserAgentEvents allowUserAgentEvents;
enteredWindow->document()->reportException(event.release(), scriptId, callStack, accessControlStatus);
} else {
enteredWindow->document()->reportException(event.release(), scriptId, callStack, accessControlStatus);
}
}
std::unique_ptr<protocol::Runtime::ExceptionDetails> InjectedScript::createExceptionDetails(v8::Local<v8::Message> message)
{
std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetailsObject = protocol::Runtime::ExceptionDetails::create()
.setText(toProtocolString(message->Get()))
.setScriptId(String16::fromInteger(message->GetScriptOrigin().ScriptID()->Value()))
.setLineNumber(message->GetLineNumber(m_context->context()).FromMaybe(1) - 1)
.setColumnNumber(message->GetStartColumn(m_context->context()).FromMaybe(0))
.build();
v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
exceptionDetailsObject->setStackTrace(m_context->inspector()->debugger()->createStackTrace(stackTrace)->buildInspectorObjectImpl());
return exceptionDetailsObject;
}
void V8LazyEventListener::fireErrorEvent(v8::Local<v8::Context> v8Context, ExecutionContext* executionContext, v8::Local<v8::Message> message)
{
String messageText = toCoreStringWithNullCheck(message->Get());
int lineNumber = 0;
int columnNumber = 0;
if (v8Call(message->GetLineNumber(v8Context), lineNumber)
&& v8Call(message->GetStartColumn(v8Context), columnNumber))
++columnNumber;
RefPtrWillBeRawPtr<ErrorEvent> event = ErrorEvent::create(messageText, m_sourceURL, lineNumber, columnNumber, &world());
AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
if (message->IsOpaque())
accessControlStatus = OpaqueResource;
else if (message->IsSharedCrossOrigin())
accessControlStatus = SharableCrossOrigin;
executionContext->reportException(event.release(), 0, nullptr, accessControlStatus);
}
std::string wavyLine(
v8::Isolate *isolate,
const v8::Local<v8::Message> &message)
{
std::string wavy_line = "";
int source_col_start_default = 0;
int source_col_start = message->GetStartColumn(
isolate->GetCurrentContext()).FromMaybe(source_col_start_default);
wavy_line += paddingOf(source_col_start);
int source_col_end_default = 0;
int source_col_end = message->GetEndColumn(
isolate->GetCurrentContext()).FromMaybe(source_col_end_default);
for (int i = source_col_start; i < source_col_end; i++)
wavy_line += "^";
return wavy_line;
}
static void messageHandlerInWorker(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
V8PerIsolateData* perIsolateData = V8PerIsolateData::from(isolate);
// Exceptions that occur in error handler should be ignored since in that case
// WorkerGlobalScope::reportException will send the exception to the worker object.
if (perIsolateData->isReportingException())
return;
perIsolateData->setReportingException(true);
ScriptState* scriptState = ScriptState::current(isolate);
// During the frame teardown, there may not be a valid context.
if (ExecutionContext* context = scriptState->executionContext()) {
String errorMessage = toCoreStringWithNullCheck(message->Get());
TOSTRING_VOID(V8StringResource<>, sourceURL, message->GetScriptOrigin().ResourceName());
int scriptId = 0;
RefPtrWillBeRawPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
int lineNumber = 0;
int columnNumber = 0;
if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
&& v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
++columnNumber;
RefPtrWillBeRawPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, sourceURL, lineNumber, columnNumber, &DOMWrapperWorld::current(isolate));
AccessControlStatus corsStatus = message->IsSharedCrossOrigin() ? SharableCrossOrigin : NotSharableCrossOrigin;
// If execution termination has been triggered as part of constructing
// the error event from the v8::Message, quietly leave.
if (!v8::V8::IsExecutionTerminating(isolate)) {
V8ErrorHandler::storeExceptionOnErrorEventWrapper(isolate, event.get(), data, scriptState->context()->Global());
context->reportException(event.release(), scriptId, callStack, corsStatus);
}
}
perIsolateData->setReportingException(false);
}
// static
std::unique_ptr<SourceLocation> SourceLocation::fromMessage(
v8::Isolate* isolate,
v8::Local<v8::Message> message,
ExecutionContext* executionContext) {
v8::Local<v8::StackTrace> stack = message->GetStackTrace();
std::unique_ptr<v8_inspector::V8StackTrace> stackTrace = nullptr;
V8PerIsolateData* data = V8PerIsolateData::from(isolate);
if (data && data->threadDebugger())
stackTrace = data->threadDebugger()->v8Inspector()->createStackTrace(stack);
int scriptId = message->GetScriptOrigin().ScriptID()->Value();
if (!stack.IsEmpty() && stack->GetFrameCount() > 0) {
int topScriptId = stack->GetFrame(0)->GetScriptId();
if (topScriptId == scriptId)
scriptId = 0;
}
int lineNumber = 0;
int columnNumber = 0;
if (v8Call(message->GetLineNumber(isolate->GetCurrentContext()),
lineNumber) &&
v8Call(message->GetStartColumn(isolate->GetCurrentContext()),
columnNumber))
++columnNumber;
if ((!scriptId || !lineNumber) && stackTrace && !stackTrace->isEmpty())
return SourceLocation::createFromNonEmptyV8StackTrace(std::move(stackTrace),
0);
String url = toCoreStringWithUndefinedOrNullCheck(
message->GetScriptOrigin().ResourceName());
if (url.isNull())
url = executionContext->url();
return SourceLocation::create(url, lineNumber, columnNumber,
std::move(stackTrace), scriptId);
}
v8::Local<v8::Object> JavaScriptCallFrame::createExceptionDetails(v8::Isolate* isolate, v8::Local<v8::Message> message)
{
v8::Local<v8::Object> exceptionDetails = v8::Object::New(isolate);
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "text"), message->Get());
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "url"), message->GetScriptOrigin().ResourceName());
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "scriptId"), v8::Integer::New(isolate, message->GetScriptOrigin().ScriptID()->Value()));
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "line"), v8::Integer::New(isolate, message->GetLineNumber()));
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "column"), v8::Integer::New(isolate, message->GetStartColumn()));
if (!message->GetStackTrace().IsEmpty())
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "stackTrace"), message->GetStackTrace()->AsArray());
else
exceptionDetails->Set(v8::String::NewFromUtf8(isolate, "stackTrace"), v8::Undefined(isolate));
return exceptionDetails;
}
