void InspectorAnimationAgent::resolveAnimation(ErrorString* errorString, const String& animationId, RefPtr<TypeBuilder::Runtime::RemoteObject>& result)
{
Animation* animation = assertAnimation(errorString, animationId);
if (!animation)
return;
if (m_idToAnimationClone.get(animationId))
animation = m_idToAnimationClone.get(animationId);
const Element* element = toKeyframeEffect(animation->effect())->target();
Document* document = element->ownerDocument();
LocalFrame* frame = document ? document->frame() : nullptr;
if (!frame) {
*errorString = "Element not associated with a document.";
return;
}
ScriptState* scriptState = ScriptState::forMainWorld(frame);
InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
if (injectedScript.isEmpty())
return;
ScriptState::Scope scope(scriptState);
v8::Isolate* isolate = scriptState->isolate();
ScriptValue scriptValue = ScriptValue(scriptState, toV8(animation, scriptState->context()->Global(), isolate));
injectedScript.releaseObjectGroup("animation");
result = injectedScript.wrapObject(scriptValue, "animation");
}
/*!
Executes \a scriptSource with this element as \c this object.
*/
QVariant QWebElement::evaluateJavaScript(const QString& scriptSource)
{
if (scriptSource.isEmpty())
return QVariant();
ScriptState* state = 0;
JSC::JSValue thisValue;
ScriptController* scriptController = 0;
if (!setupScriptContext(m_element, thisValue, state, scriptController))
return QVariant();
JSC::ScopeChain& scopeChain = state->dynamicGlobalObject()->globalScopeChain();
JSC::UString script((const UChar*)scriptSource.data(), scriptSource.length());
JSC::Completion completion = JSC::evaluate(state, scopeChain, JSC::makeSource(script), thisValue);
if ((completion.complType() != JSC::ReturnValue) && (completion.complType() != JSC::Normal))
return QVariant();
JSC::JSValue result = completion.value();
if (!result)
return QVariant();
int distance = 0;
return JSC::Bindings::convertValueToQVariant(state, result, QMetaType::Void, &distance);
}
ScriptValue InjectedScriptBase::callFunctionWithEvalEnabled(ScriptFunctionCall& function, bool& hadException) const
{
ASSERT(!isEmpty());
ExecutionContext* executionContext = m_injectedScriptObject.scriptState()->executionContext();
ScriptState::Scope scope(m_injectedScriptObject.scriptState());
v8::Local<v8::Function> functionObj = function.function();
DevToolsFunctionInfo info(functionObj);
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "FunctionCall", "data", InspectorFunctionCallEvent::data(executionContext, info.scriptId(), "InjectedScriptSource.js", info.lineNumber()));
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willCallFunction(executionContext, info);
ScriptState* scriptState = m_injectedScriptObject.scriptState();
bool evalIsDisabled = false;
if (scriptState) {
evalIsDisabled = !scriptState->evalEnabled();
// Temporarily enable allow evals for inspector.
if (evalIsDisabled)
scriptState->setEvalEnabled(true);
}
ScriptValue resultValue = function.call(hadException);
if (evalIsDisabled)
scriptState->setEvalEnabled(false);
InspectorInstrumentation::didCallFunction(cookie);
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
return resultValue;
}
ScriptValue InjectedScriptBase::callFunctionWithEvalEnabled(ScriptFunctionCall& function, bool& hadException) const
{
ASSERT(!isEmpty());
ExecutionContext* executionContext = m_injectedScriptObject.scriptState()->executionContext();
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "FunctionCall", "data", InspectorFunctionCallEvent::data(executionContext, 0, name(), 1));
// FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willCallFunction(executionContext, 0, name(), 1);
ScriptState* scriptState = m_injectedScriptObject.scriptState();
bool evalIsDisabled = false;
if (scriptState) {
evalIsDisabled = !scriptState->evalEnabled();
// Temporarily enable allow evals for inspector.
if (evalIsDisabled)
scriptState->setEvalEnabled(true);
}
ScriptValue resultValue = function.call(hadException);
if (evalIsDisabled)
scriptState->setEvalEnabled(false);
InspectorInstrumentation::didCallFunction(cookie);
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", "data", InspectorUpdateCountersEvent::data());
return resultValue;
}
static void messageHandlerInWorker(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
V8PerIsolateData* perIsolateData = V8PerIsolateData::from(isolate);
// During the frame teardown, there may not be a valid context.
ScriptState* scriptState = ScriptState::current(isolate);
if (!scriptState->contextIsValid())
return;
// 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);
ExecutionContext* context = scriptState->getExecutionContext();
std::unique_ptr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
ErrorEvent* event = ErrorEvent::create(toCoreStringWithNullCheck(message->Get()), std::move(location), &scriptState->world());
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 (!isolate->IsExecutionTerminating()) {
V8ErrorHandler::storeExceptionOnErrorEventWrapper(scriptState, event, data, scriptState->context()->Global());
scriptState->getExecutionContext()->reportException(event, corsStatus);
}
perIsolateData->setReportingException(false);
}
void WebDevToolsFrontendImpl::didClearWindowObject(WebLocalFrameImpl* frame)
{
if (m_webFrame == frame) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
ScriptState* scriptState = ScriptState::forMainWorld(m_webFrame->frame());
ScriptState::Scope scope(scriptState);
if (m_devtoolsHost)
m_devtoolsHost->disconnectClient();
m_devtoolsHost = DevToolsHost::create(this, m_webFrame->frame());
v8::Local<v8::Object> global = scriptState->context()->Global();
v8::Local<v8::Value> devtoolsHostObj = toV8(m_devtoolsHost.get(), global, scriptState->isolate());
ASSERT(!devtoolsHostObj.IsEmpty());
global->Set(v8AtomicString(isolate, "DevToolsHost"), devtoolsHostObj);
}
if (m_injectedScriptForOrigin.isEmpty())
return;
String origin = frame->securityOrigin().toString();
String script = m_injectedScriptForOrigin.get(origin);
if (script.isEmpty())
return;
static int s_lastScriptId = 0;
StringBuilder scriptWithId;
scriptWithId.append(script);
scriptWithId.append('(');
scriptWithId.appendNumber(++s_lastScriptId);
scriptWithId.append(')');
frame->frame()->script().executeScriptInMainWorld(scriptWithId.toString());
}
void InspectorAnimationAgent::resolveAnimation(
ErrorString* errorString,
const String& animationId,
std::unique_ptr<v8_inspector::protocol::Runtime::API::RemoteObject>*
result) {
blink::Animation* animation = assertAnimation(errorString, animationId);
if (!animation)
return;
if (m_idToAnimationClone.get(animationId))
animation = m_idToAnimationClone.get(animationId);
const Element* element = toKeyframeEffect(animation->effect())->target();
Document* document = element->ownerDocument();
LocalFrame* frame = document ? document->frame() : nullptr;
ScriptState* scriptState = frame ? ScriptState::forMainWorld(frame) : nullptr;
if (!scriptState) {
*errorString = "Element not associated with a document.";
return;
}
ScriptState::Scope scope(scriptState);
static const char kAnimationObjectGroup[] = "animation";
m_v8Session->releaseObjectGroup(
toV8InspectorStringView(kAnimationObjectGroup));
*result = m_v8Session->wrapObject(
scriptState->context(),
toV8(animation, scriptState->context()->Global(), scriptState->isolate()),
toV8InspectorStringView(kAnimationObjectGroup));
if (!*result)
*errorString = "Element not associated with a document.";
}
PassRefPtr<JSONValue> toJSONValue(const ScriptValue& value)
{
ScriptState* scriptState = value.scriptState();
ASSERT(scriptState->contextIsValid());
ScriptState::Scope scope(scriptState);
NonThrowableExceptionState exceptionState;
return ScriptValue::to<JSONValuePtr>(scriptState->isolate(), value, exceptionState);
}
static void messageHandlerInMainThread(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
{
ASSERT(isMainThread());
// It's possible that messageHandlerInMainThread() is invoked while we're initializing a window.
// In that half-baked situation, we don't have a valid context nor a valid world,
// so just return immediately.
if (DOMWrapperWorld::windowIsBeingInitialized())
return;
v8::Isolate* isolate = v8::Isolate::GetCurrent();
// If called during context initialization, there will be no entered window.
LocalDOMWindow* enteredWindow = enteredDOMWindow(isolate);
if (!enteredWindow)
return;
String errorMessage = toCoreString(message->Get());
v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
RefPtr<ScriptCallStack> callStack = nullptr;
int scriptId = message->GetScriptOrigin().ScriptID()->Value();
// Currently stack trace is only collected when inspector is open.
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
callStack = createScriptCallStack(stackTrace, ScriptCallStack::maxCallStackSizeToCapture, isolate);
bool success = false;
int topScriptId = callStack->at(0).scriptId().toInt(&success);
if (success && topScriptId == scriptId)
scriptId = 0;
} else {
Vector<ScriptCallFrame> callFrames;
callStack = ScriptCallStack::create(callFrames);
}
v8::Handle<v8::Value> resourceName = message->GetScriptOrigin().ResourceName();
bool shouldUseDocumentURL = resourceName.IsEmpty() || !resourceName->IsString();
String resource = shouldUseDocumentURL ? enteredWindow->document()->url() : toCoreString(resourceName.As<v8::String>());
ScriptState* scriptState = ScriptState::current(isolate);
RefPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, resource, message->GetLineNumber(), message->GetStartColumn() + 1, &scriptState->world());
if (V8DOMWrapper::isDOMWrapper(data)) {
v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(data);
const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
DOMException* exception = V8DOMException::toNative(obj);
if (exception && !exception->messageForConsole().isEmpty())
event->setUnsanitizedMessage("Uncaught " + exception->toStringForConsole());
}
}
// 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(event.get(), data, scriptState->context()->Global(), isolate);
}
enteredWindow->document()->reportException(event.release(), scriptId, callStack);
}
void injectInternalsObject(v8::Local<v8::Context> context)
{
ScriptState* scriptState = ScriptState::from(context);
ScriptState::Scope scope(scriptState);
v8::Handle<v8::Object> global = scriptState->context()->Global();
ExecutionContext* executionContext = scriptState->executionContext();
if (executionContext->isDocument())
global->Set(v8::String::NewFromUtf8(scriptState->isolate(), Internals::internalsId), toV8(Internals::create(toDocument(executionContext)), global, scriptState->isolate()));
}
void willCreatePossiblyOrphanedTreeByRemovalSlowCase(Node* root)
{
ScriptState* scriptState = mainWorldScriptState(root->document()->frame());
if (!scriptState)
return;
JSLockHolder lock(scriptState);
toJS(scriptState, static_cast<JSDOMGlobalObject*>(scriptState->lexicalGlobalObject()), root);
}
void V8InjectedScriptHost::inspectCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (info.Length() < 2)
return;
InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
ScriptState* scriptState = ScriptState::current(info.GetIsolate());
ScriptState::Scope scope(scriptState);
host->inspectImpl(toJSONValue(scriptState->context(), info[0]), toJSONValue(scriptState->context(), info[1]));
}
ScriptState* ScriptState::forWorld(LocalFrame* frame, DOMWrapperWorld& world) {
ASSERT(frame);
v8::HandleScope handleScope(toIsolate(frame));
v8::Local<v8::Context> context = toV8Context(frame, world);
if (context.IsEmpty())
return nullptr;
ScriptState* scriptState = ScriptState::from(context);
ASSERT(scriptState->contextIsValid());
return scriptState;
}
void FetchManager::Loader::failed()
{
if (m_failed)
return;
if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
return;
m_failed = true;
ScriptState* state = m_resolver->scriptState();
ScriptState::Scope scope(state);
m_resolver->reject(V8ThrowException::createTypeError("Failed to fetch", state->isolate()));
notifyFinished();
}
static void promiseRejectHandler(v8::PromiseRejectMessage data, RejectedPromises& rejectedPromises, const String& fallbackResourceName)
{
if (data.GetEvent() == v8::kPromiseHandlerAddedAfterReject) {
rejectedPromises.handlerAdded(data);
return;
}
ASSERT(data.GetEvent() == v8::kPromiseRejectWithNoHandler);
v8::Local<v8::Promise> promise = data.GetPromise();
v8::Isolate* isolate = promise->GetIsolate();
ScriptState* scriptState = ScriptState::current(isolate);
v8::Local<v8::Value> exception = data.GetValue();
if (V8DOMWrapper::isWrapper(isolate, exception)) {
// Try to get the stack & location from a wrapped exception object (e.g. DOMException).
ASSERT(exception->IsObject());
v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(exception);
v8::Local<v8::Value> error = V8HiddenValue::getHiddenValue(scriptState, obj, V8HiddenValue::error(isolate));
if (!error.IsEmpty())
exception = error;
}
int scriptId = 0;
int lineNumber = 0;
int columnNumber = 0;
String resourceName = fallbackResourceName;
String errorMessage;
AccessControlStatus corsStatus = NotSharableCrossOrigin;
RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
v8::Local<v8::Message> message = v8::Exception::CreateMessage(isolate, exception);
if (!message.IsEmpty()) {
V8StringResource<> v8ResourceName(message->GetScriptOrigin().ResourceName());
if (v8ResourceName.prepare())
resourceName = v8ResourceName;
scriptId = message->GetScriptOrigin().ScriptID()->Value();
if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
&& v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
++columnNumber;
// message->Get() can be empty here. https://crbug.com/450330
errorMessage = toCoreStringWithNullCheck(message->Get());
callStack = extractCallStack(isolate, message, &scriptId);
if (message->IsSharedCrossOrigin())
corsStatus = SharableCrossOrigin;
}
String messageForConsole = extractMessageForConsole(isolate, data.GetValue());
if (!messageForConsole.isEmpty())
errorMessage = "Uncaught " + messageForConsole;
rejectedPromises.rejectedWithNoHandler(scriptState, data, errorMessage, resourceName, scriptId, lineNumber, columnNumber, callStack, corsStatus);
}
void V8HTMLElement::HTMLConstructor(
const v8::FunctionCallbackInfo<v8::Value>& info) {
DCHECK(info.IsConstructCall());
v8::Isolate* isolate = info.GetIsolate();
ScriptState* scriptState = ScriptState::current(isolate);
if (!RuntimeEnabledFeatures::customElementsV1Enabled() ||
!scriptState->world().isMainWorld()) {
V8ThrowException::throwTypeError(info.GetIsolate(), "Illegal constructor");
return;
}
LocalDOMWindow* window = scriptState->domWindow();
ScriptCustomElementDefinition* definition =
ScriptCustomElementDefinition::forConstructor(
scriptState, window->customElements(), info.NewTarget());
if (!definition) {
V8ThrowException::throwTypeError(isolate, "Illegal constructor");
return;
}
ExceptionState exceptionState(ExceptionState::ConstructionContext,
"HTMLElement", info.Holder(), isolate);
Element* element;
if (definition->constructionStack().isEmpty()) {
// This is an element being created with 'new' from script
element = definition->createElementForConstructor(*window->document());
} else {
element = definition->constructionStack().last();
if (element) {
// This is an element being upgraded that has called super
definition->constructionStack().last().clear();
} else {
// During upgrade an element has invoked the same constructor
// before calling 'super' and that invocation has poached the
// element.
exceptionState.throwDOMException(InvalidStateError,
"this instance is already constructed");
return;
}
}
const WrapperTypeInfo* wrapperType = element->wrapperTypeInfo();
v8::Local<v8::Object> wrapper = V8DOMWrapper::associateObjectWithWrapper(
isolate, element, wrapperType, info.Holder());
// If the element had a wrapper, we now update and return that
// instead.
v8SetReturnValue(info, wrapper);
wrapper->SetPrototype(scriptState->context(), definition->prototype())
.ToChecked();
}
void injectInternalsObject(v8::Local<v8::Context> context)
{
ScriptState* scriptState = ScriptState::from(context);
ScriptState::Scope scope(scriptState);
v8::Local<v8::Object> global = scriptState->context()->Global();
ExecutionContext* executionContext = scriptState->executionContext();
if (executionContext->isDocument()) {
v8::Local<v8::Value> internals = toV8(Internals::create(toDocument(executionContext)), global, scriptState->isolate());
ASSERT(!internals.IsEmpty());
v8CallOrCrash(global->Set(scriptState->context(), v8AtomicString(scriptState->isolate(), Internals::internalsId), internals));
}
}
// Create a V8 object with an interceptor of NPObjectPropertyGetter.
void ScriptController::bindToWindowObject(LocalFrame* frame, const String& key, NPObject* object)
{
ScriptState* scriptState = ScriptState::forMainWorld(frame);
if (!scriptState->contextIsValid())
return;
ScriptState::Scope scope(scriptState);
v8::Handle<v8::Object> value = createV8ObjectForNPObject(m_isolate, object, 0);
// Attach to the global object.
scriptState->context()->Global()->Set(v8String(m_isolate, key), value);
}
// Create a V8 object with an interceptor of NPObjectPropertyGetter.
bool ScriptController::bindToWindowObject(LocalFrame* frame, const String& key, NPObject* object)
{
ScriptState* scriptState = ScriptState::forMainWorld(frame);
if (!scriptState->contextIsValid())
return false;
ScriptState::Scope scope(scriptState);
v8::Local<v8::Object> value = createV8ObjectForNPObject(isolate(), object, 0);
// Attach to the global object.
return v8CallBoolean(scriptState->context()->Global()->Set(scriptState->context(), v8String(isolate(), key), value));
}
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);
}
}
void DevToolsHost::showContextMenu(LocalFrame* targetFrame, float x, float y, const Vector<ContextMenuItem>& items)
{
ASSERT(m_frontendFrame);
ScriptState* frontendScriptState = ScriptState::forMainWorld(m_frontendFrame);
ScriptValue devtoolsApiObject = frontendScriptState->getFromGlobalObject("DevToolsAPI");
ASSERT(devtoolsApiObject.isObject());
RefPtrWillBeRawPtr<FrontendMenuProvider> menuProvider = FrontendMenuProvider::create(this, devtoolsApiObject, items);
m_menuProvider = menuProvider.get();
float zoom = targetFrame->pageZoomFactor();
if (m_client)
m_client->showContextMenu(targetFrame, x * zoom, y * zoom, menuProvider);
}
void resetInternalsObject(v8::Local<v8::Context> context)
{
// This can happen if JavaScript is disabled in the main frame.
if (context.IsEmpty())
return;
ScriptState* scriptState = ScriptState::from(context);
ScriptState::Scope scope(scriptState);
Page* page = toDocument(scriptState->executionContext())->frame()->page();
ASSERT(page);
Internals::resetToConsistentState(page);
InternalSettings::from(*page)->resetToConsistentState();
}
static void messageHandlerInMainThread(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
{
ASSERT(isMainThread());
v8::Isolate* isolate = v8::Isolate::GetCurrent();
if (isolate->GetEnteredContext().IsEmpty())
return;
// If called during context initialization, there will be no entered context.
ScriptState* scriptState = ScriptState::current(isolate);
if (!scriptState->contextIsValid())
return;
ExecutionContext* context = scriptState->getExecutionContext();
std::unique_ptr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
if (message->IsOpaque())
accessControlStatus = OpaqueResource;
else if (message->IsSharedCrossOrigin())
accessControlStatus = SharableCrossOrigin;
ErrorEvent* event = ErrorEvent::create(toCoreStringWithNullCheck(message->Get()), std::move(location), &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?
if (context->isDocument()) {
LocalFrame* frame = toDocument(context)->frame();
if (frame && frame->script().existingWindowProxy(scriptState->world())) {
V8ErrorHandler::storeExceptionOnErrorEventWrapper(scriptState, event, 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;
context->reportException(event, accessControlStatus);
} else {
context->reportException(event, accessControlStatus);
}
}
void V8MessageEvent::dataAttributeGetterCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
ScriptState* scriptState = ScriptState::current(info.GetIsolate());
auto privateCachedData =
V8PrivateProperty::getMessageEventCachedData(info.GetIsolate());
v8::Local<v8::Value> cachedData =
privateCachedData.get(scriptState->context(), info.Holder());
if (!cachedData.IsEmpty()) {
v8SetReturnValue(info, cachedData);
return;
}
MessageEvent* event = V8MessageEvent::toImpl(info.Holder());
v8::Local<v8::Value> result;
switch (event->getDataType()) {
case MessageEvent::DataTypeScriptValue:
result = event->dataAsScriptValue().v8ValueFor(scriptState);
if (result.IsEmpty())
result = v8::Null(info.GetIsolate());
break;
case MessageEvent::DataTypeSerializedScriptValue:
if (SerializedScriptValue* serializedValue =
event->dataAsSerializedScriptValue()) {
MessagePortArray ports = event->ports();
result = serializedValue->deserialize(info.GetIsolate(), &ports);
} else {
result = v8::Null(info.GetIsolate());
}
break;
case MessageEvent::DataTypeString:
result = v8String(info.GetIsolate(), event->dataAsString());
break;
case MessageEvent::DataTypeBlob:
result = toV8(event->dataAsBlob(), info.Holder(), info.GetIsolate());
break;
case MessageEvent::DataTypeArrayBuffer:
result =
toV8(event->dataAsArrayBuffer(), info.Holder(), info.GetIsolate());
break;
}
// Store the result as a private value so this callback returns the cached
// result in future invocations.
privateCachedData.set(scriptState->context(), info.Holder(), result);
v8SetReturnValue(info, result);
}
ScriptObject InspectorCanvasAgent::notifyRenderingContextWasWrapped(const ScriptObject& wrappedContext)
{
ASSERT(m_frontend);
ScriptState* scriptState = wrappedContext.scriptState();
DOMWindow* domWindow = 0;
if (scriptState)
domWindow = scriptState->domWindow();
Frame* frame = domWindow ? domWindow->frame() : 0;
if (frame && !m_framesWithUninstrumentedCanvases.contains(frame))
m_framesWithUninstrumentedCanvases.set(frame, false);
String frameId = m_pageAgent->frameId(frame);
if (!frameId.isEmpty())
m_frontend->contextCreated(frameId);
return wrappedContext;
}
void AcceptConnectionObserver::responseWasResolved(const ScriptValue& value)
{
ASSERT(executionContext());
if (!m_resolver) {
// TODO(mek): Get rid of this block when observer is only used for
// service port connect events.
if (!value.v8Value()->IsTrue()) {
responseWasRejected();
return;
}
ServiceWorkerGlobalScopeClient::from(executionContext())->didHandleCrossOriginConnectEvent(m_eventID, true);
m_state = Done;
return;
}
ScriptState* scriptState = m_resolver->scriptState();
ExceptionState exceptionState(ExceptionState::UnknownContext, nullptr, nullptr, scriptState->context()->Global(), scriptState->isolate());
ServicePortConnectResponse response = ScriptValue::to<ServicePortConnectResponse>(scriptState->isolate(), value, exceptionState);
if (exceptionState.hadException()) {
exceptionState.reject(m_resolver.get());
m_resolver = nullptr;
responseWasRejected();
return;
}
if (!response.hasAccept() || !response.accept()) {
responseWasRejected();
return;
}
WebServicePort webPort;
webPort.targetUrl = m_targetURL;
if (response.hasName())
webPort.name = response.name();
if (response.hasData()) {
webPort.data = SerializedScriptValueFactory::instance().create(scriptState->isolate(), response.data(), nullptr, exceptionState)->toWireString();
if (exceptionState.hadException()) {
exceptionState.reject(m_resolver.get());
m_resolver = nullptr;
responseWasRejected();
return;
}
}
webPort.id = m_portID;
ServicePort* port = ServicePort::create(m_collection, webPort);
m_collection->addPort(port);
m_resolver->resolve(port);
m_callbacks->onSuccess(&webPort);
m_state = Done;
}
void ConsoleMessage::addToFrontend(InspectorFrontend::Console* frontend, InjectedScriptManager* injectedScriptManager, bool generatePreview)
{
RefPtr<TypeBuilder::Console::ConsoleMessage> jsonObj = TypeBuilder::Console::ConsoleMessage::create()
.setSource(messageSourceValue(m_source))
.setLevel(messageLevelValue(m_level))
.setText(m_message)
.setTimestamp(m_timestamp);
// FIXME: only send out type for ConsoleAPI source messages.
jsonObj->setType(messageTypeValue(m_type));
jsonObj->setLine(static_cast<int>(m_line));
jsonObj->setColumn(static_cast<int>(m_column));
jsonObj->setUrl(m_url);
ScriptState* scriptState = m_scriptState.get();
if (scriptState && scriptState->executionContext()->isDocument())
jsonObj->setExecutionContextId(injectedScriptManager->injectedScriptIdFor(scriptState));
if (m_source == NetworkMessageSource && !m_requestId.isEmpty())
jsonObj->setNetworkRequestId(m_requestId);
if (m_arguments && m_arguments->argumentCount()) {
InjectedScript injectedScript = injectedScriptManager->injectedScriptFor(m_arguments->scriptState());
if (!injectedScript.isEmpty()) {
RefPtr<TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject> > jsonArgs = TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject>::create();
if (m_type == TableMessageType && generatePreview && m_arguments->argumentCount()) {
ScriptValue table = m_arguments->argumentAt(0);
ScriptValue columns = m_arguments->argumentCount() > 1 ? m_arguments->argumentAt(1) : ScriptValue();
RefPtr<TypeBuilder::Runtime::RemoteObject> inspectorValue = injectedScript.wrapTable(table, columns);
if (!inspectorValue) {
ASSERT_NOT_REACHED();
return;
}
jsonArgs->addItem(inspectorValue);
} else {
for (unsigned i = 0; i < m_arguments->argumentCount(); ++i) {
RefPtr<TypeBuilder::Runtime::RemoteObject> inspectorValue = injectedScript.wrapObject(m_arguments->argumentAt(i), "console", generatePreview);
if (!inspectorValue) {
ASSERT_NOT_REACHED();
return;
}
jsonArgs->addItem(inspectorValue);
}
}
jsonObj->setParameters(jsonArgs);
}
}
if (m_callStack)
jsonObj->setStackTrace(m_callStack->buildInspectorArray());
frontend->messageAdded(jsonObj);
frontend->flush();
}
void FetchManager::Loader::failed(const String& message)
{
if (m_failed || m_finished)
return;
m_failed = true;
if (!message.isEmpty())
executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
if (m_resolver) {
if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
return;
ScriptState* state = m_resolver->scriptState();
ScriptState::Scope scope(state);
m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), "Failed to fetch"));
}
notifyFinished();
}
void ScriptDebugServer::dispatchDidPause(ScriptDebugListener* listener)
{
ASSERT(m_paused);
JSGlobalObject* globalObject = m_currentCallFrame->scopeChain()->globalObject.get();
ScriptState* state = globalObject->globalExec();
JSValue jsCallFrame;
{
if (m_currentCallFrame->isValid() && globalObject->inherits(&JSDOMGlobalObject::s_info)) {
JSDOMGlobalObject* domGlobalObject = jsCast<JSDOMGlobalObject*>(globalObject);
JSLock lock(SilenceAssertionsOnly);
jsCallFrame = toJS(state, domGlobalObject, m_currentCallFrame.get());
} else
jsCallFrame = jsUndefined();
}
listener->didPause(state, ScriptValue(state->globalData(), jsCallFrame), ScriptValue());
}
V8DOMActivityLogger* V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld()
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
if (!isolate->InContext())
return 0;
ScriptState* scriptState = ScriptState::current(isolate);
if (!scriptState->world().isIsolatedWorld())
return 0;
V8PerContextData* contextData = scriptState->perContextData();
if (!contextData)
return 0;
return contextData->activityLogger();
}