static JSC::JSValue handleInitMessageEvent(JSMessageEvent* jsEvent, JSC::ExecState& state)
{
const String& typeArg = state.argument(0).toString(&state)->value(&state);
bool canBubbleArg = state.argument(1).toBoolean(&state);
bool cancelableArg = state.argument(2).toBoolean(&state);
const String originArg = valueToUSVString(&state, state.argument(4));
const String lastEventIdArg = state.argument(5).toString(&state)->value(&state);
DOMWindow* sourceArg = JSDOMWindow::toWrapped(state, state.argument(6));
std::unique_ptr<MessagePortArray> messagePorts;
std::unique_ptr<ArrayBufferArray> arrayBuffers;
if (!state.argument(7).isUndefinedOrNull()) {
messagePorts = std::make_unique<MessagePortArray>();
arrayBuffers = std::make_unique<ArrayBufferArray>();
fillMessagePortArray(state, state.argument(7), *messagePorts, *arrayBuffers);
if (state.hadException())
return jsUndefined();
}
Deprecated::ScriptValue dataArg(state.vm(), state.argument(3));
if (state.hadException())
return jsUndefined();
MessageEvent& event = jsEvent->wrapped();
event.initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, WTFMove(messagePorts));
jsEvent->m_data.set(state.vm(), jsEvent, dataArg.jsValue());
return jsUndefined();
}
JSC::JSValue JSApplePayPaymentAuthorizedEvent::payment(JSC::ExecState& exec) const
{
if (!m_payment)
m_payment.set(exec.vm(), this, wrapped().payment().toJS(exec));
return m_payment.get();
}
JSValue JSDocument::getCSSCanvasContext(JSC::ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (UNLIKELY(state.argumentCount() < 4))
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto contextId = state.uncheckedArgument(0).toWTFString(&state);
if (UNLIKELY(state.hadException()))
return jsUndefined();
auto name = state.uncheckedArgument(1).toWTFString(&state);
if (UNLIKELY(state.hadException()))
return jsUndefined();
auto width = convert<int32_t>(state, state.uncheckedArgument(2), NormalConversion);
if (UNLIKELY(state.hadException()))
return jsUndefined();
auto height = convert<int32_t>(state, state.uncheckedArgument(3), NormalConversion);
if (UNLIKELY(state.hadException()))
return jsUndefined();
auto* context = wrapped().getCSSCanvasContext(WTFMove(contextId), WTFMove(name), WTFMove(width), WTFMove(height));
if (!context)
return jsNull();
#if ENABLE(WEBGL)
if (is<WebGLRenderingContextBase>(*context))
return toJS(&state, globalObject(), downcast<WebGLRenderingContextBase>(*context));
#endif
return toJS(&state, globalObject(), downcast<CanvasRenderingContext2D>(*context));
}
static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState& state, WebGLRenderingContextBase& context)
{
if (state.argumentCount() != 2)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
WebGLUniformLocation* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(0));
if (!location && !state.uncheckedArgument(0).isUndefinedOrNull())
return throwTypeError(&state);
RefPtr<Int32Array> webGLArray = toInt32Array(state.uncheckedArgument(1));
ExceptionCode ec = 0;
if (webGLArray) {
switch (f) {
case f_uniform1v:
context.uniform1iv(location, *webGLArray, ec);
break;
case f_uniform2v:
context.uniform2iv(location, *webGLArray, ec);
break;
case f_uniform3v:
context.uniform3iv(location, *webGLArray, ec);
break;
case f_uniform4v:
context.uniform4iv(location, *webGLArray, ec);
break;
default:
break;
}
setDOMException(&state, ec);
return jsUndefined();
}
Vector<int, 64> array;
if (!toVector(state, state.uncheckedArgument(1), array))
return throwTypeError(&state);
switch (f) {
case f_uniform1v:
context.uniform1iv(location, array.data(), array.size(), ec);
break;
case f_uniform2v:
context.uniform2iv(location, array.data(), array.size(), ec);
break;
case f_uniform3v:
context.uniform3iv(location, array.data(), array.size(), ec);
break;
case f_uniform4v:
context.uniform4iv(location, array.data(), array.size(), ec);
break;
default:
break;
}
setDOMException(&state, ec);
return jsUndefined();
}
void ReadableJSStream::storeError(JSC::ExecState& exec, JSValue error)
{
if (m_error)
return;
m_error.set(exec.vm(), error);
changeStateToErrored();
}
JSC::JSValue deserializeIDBValueDataToJSValue(JSC::ExecState& exec, const ThreadSafeDataBuffer& valueData)
{
if (!valueData.data())
return jsUndefined();
const Vector<uint8_t>& data = *valueData.data();
JSValue result;
if (data.size()) {
RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::createFromWireBytes(data);
exec.vm().apiLock().lock();
result = serializedValue->deserialize(&exec, exec.lexicalGlobalObject(), 0, NonThrowing);
exec.vm().apiLock().unlock();
} else
result = jsNull();
return result;
}
void ScriptDebugServer::dispatchDidPause(ScriptDebugListener* listener)
{
ASSERT(isPaused());
DebuggerCallFrame* debuggerCallFrame = currentDebuggerCallFrame();
JSGlobalObject* globalObject = debuggerCallFrame->scope()->globalObject();
JSC::ExecState* state = globalObject->globalExec();
RefPtr<JavaScriptCallFrame> javaScriptCallFrame = JavaScriptCallFrame::create(debuggerCallFrame);
JSValue jsCallFrame = toJS(state, globalObject, javaScriptCallFrame.get());
listener->didPause(state, Deprecated::ScriptValue(state->vm(), jsCallFrame), Deprecated::ScriptValue());
}
void CustomEvent::initCustomEvent(JSC::ExecState& state, const AtomicString& type, bool canBubble, bool cancelable, JSC::JSValue detail)
{
if (dispatched())
return;
initEvent(type, canBubble, cancelable);
m_detail = { state.vm(), detail };
m_serializedDetail = nullptr;
m_triedToSerialize = false;
}
static inline JSC::JSValue callFunction(JSC::ExecState& state, JSC::JSValue jsFunction, JSC::JSValue thisValue, const JSC::ArgList& arguments)
{
VM& vm = state.vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
JSC::CallData callData;
auto callType = JSC::getCallData(vm, jsFunction, callData);
ASSERT(callType != JSC::CallType::None);
auto result = call(&state, jsFunction, callType, callData, thisValue, arguments);
scope.assertNoException();
return result;
}
static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecState& state, WebGLRenderingContextBase& context)
{
if (state.argumentCount() != 3)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
WebGLUniformLocation* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(0));
if (!location && !state.uncheckedArgument(0).isUndefinedOrNull())
return throwTypeError(&state);
bool transpose = state.uncheckedArgument(1).toBoolean(&state);
if (state.hadException())
return jsUndefined();
RefPtr<Float32Array> webGLArray = toFloat32Array(state.uncheckedArgument(2));
ExceptionCode ec = 0;
if (webGLArray) {
switch (f) {
case f_uniformMatrix2fv:
context.uniformMatrix2fv(location, transpose, *webGLArray, ec);
break;
case f_uniformMatrix3fv:
context.uniformMatrix3fv(location, transpose, *webGLArray, ec);
break;
case f_uniformMatrix4fv:
context.uniformMatrix4fv(location, transpose, *webGLArray, ec);
break;
}
setDOMException(&state, ec);
return jsUndefined();
}
Vector<float, 64> array;
if (!toVector(state, state.uncheckedArgument(2), array))
return throwTypeError(&state);
switch (f) {
case f_uniformMatrix2fv:
context.uniformMatrix2fv(location, transpose, array.data(), array.size(), ec);
break;
case f_uniformMatrix3fv:
context.uniformMatrix3fv(location, transpose, array.data(), array.size(), ec);
break;
case f_uniformMatrix4fv:
context.uniformMatrix4fv(location, transpose, array.data(), array.size(), ec);
break;
}
setDOMException(&state, ec);
return jsUndefined();
}
void ScriptDebugServer::dispatchDidPause(ScriptDebugListener* listener)
{
ASSERT(m_paused);
DebuggerCallFrame* debuggerCallFrame = currentDebuggerCallFrame();
JSGlobalObject* globalObject = debuggerCallFrame->scope()->globalObject();
JSC::ExecState* state = globalObject->globalExec();
RefPtr<JavaScriptCallFrame> javaScriptCallFrame = JavaScriptCallFrame::create(debuggerCallFrame);
JSValue jsCallFrame;
{
if (globalObject->inherits(JSDOMGlobalObject::info())) {
JSDOMGlobalObject* domGlobalObject = jsCast<JSDOMGlobalObject*>(globalObject);
JSLockHolder lock(state);
jsCallFrame = toJS(state, domGlobalObject, javaScriptCallFrame.get());
} else
jsCallFrame = jsUndefined();
}
listener->didPause(state, ScriptValue(state->vm(), jsCallFrame), ScriptValue());
}
bool toVector(JSC::ExecState& state, JSC::JSValue value, Vector<T, inlineCapacity>& vector)
{
if (!value.isObject())
return false;
JSC::JSObject* object = asObject(value);
int32_t length = object->get(&state, state.vm().propertyNames->length).toInt32(&state);
if (!vector.tryReserveCapacity(length))
return false;
vector.resize(length);
for (int32_t i = 0; i < length; ++i) {
JSC::JSValue v = object->get(&state, i);
if (state.hadException())
return false;
vector[i] = static_cast<T>(v.toNumber(&state));
}
return true;
}
Ref<ReadableStream> ReadableStream::create(JSC::ExecState& execState, RefPtr<ReadableStreamSource>&& source)
{
VM& vm = execState.vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(execState.lexicalGlobalObject());
auto* constructor = JSC::asObject(globalObject.get(&execState, clientData.builtinNames().ReadableStreamPrivateName()));
ConstructData constructData;
ConstructType constructType = constructor->methodTable(vm)->getConstructData(constructor, constructData);
ASSERT(constructType != ConstructType::None);
MarkedArgumentBuffer args;
args.append(source ? toJSNewlyCreated(&execState, &globalObject, source.releaseNonNull()) : JSC::jsUndefined());
ASSERT(!args.hasOverflowed());
auto newReadableStream = jsDynamicCast<JSReadableStream*>(vm, JSC::construct(&execState, constructor, constructType, constructData, args));
scope.assertNoException();
return create(globalObject, *newReadableStream);
}
bool ScriptDebugServer::evaluateBreakpointAction(const ScriptBreakpointAction& breakpointAction)
{
DebuggerCallFrame* debuggerCallFrame = currentDebuggerCallFrame();
switch (breakpointAction.type) {
case ScriptBreakpointActionTypeLog: {
dispatchBreakpointActionLog(debuggerCallFrame->exec(), breakpointAction.data);
break;
}
case ScriptBreakpointActionTypeEvaluate: {
JSValue exception;
debuggerCallFrame->evaluate(breakpointAction.data, exception);
if (exception)
reportException(debuggerCallFrame->exec(), exception);
break;
}
case ScriptBreakpointActionTypeSound:
dispatchBreakpointActionSound(debuggerCallFrame->exec());
break;
case ScriptBreakpointActionTypeProbe: {
JSValue exception;
JSValue result = debuggerCallFrame->evaluate(breakpointAction.data, exception);
if (exception)
reportException(debuggerCallFrame->exec(), exception);
JSC::ExecState* state = debuggerCallFrame->scope()->globalObject()->globalExec();
Deprecated::ScriptValue wrappedResult = Deprecated::ScriptValue(state->vm(), exception ? exception : result);
dispatchDidSampleProbe(state, breakpointAction.identifier, wrappedResult);
break;
}
default:
ASSERT_NOT_REACHED();
}
return true;
}
JSValue idbKeyDataToJSValue(JSC::ExecState& exec, const IDBKeyData& keyData)
{
if (keyData.isNull())
return jsUndefined();
Locker<JSLock> locker(exec.vm().apiLock());
switch (keyData.type()) {
case KeyType::Array:
{
const Vector<IDBKeyData>& inArray = keyData.array();
size_t size = inArray.size();
JSArray* outArray = constructEmptyArray(&exec, 0, exec.lexicalGlobalObject(), size);
for (size_t i = 0; i < size; ++i) {
auto& arrayKey = inArray.at(i);
outArray->putDirectIndex(&exec, i, idbKeyDataToJSValue(exec, arrayKey));
}
return JSValue(outArray);
}
case KeyType::String:
return jsStringWithCache(&exec, keyData.string());
case KeyType::Date:
return jsDateOrNull(&exec, keyData.date());
case KeyType::Number:
return jsNumber(keyData.number());
case KeyType::Min:
case KeyType::Max:
case KeyType::Invalid:
ASSERT_NOT_REACHED();
return jsUndefined();
}
ASSERT_NOT_REACHED();
return jsUndefined();
}
static JSC::JSValue handleInitMessageEvent(JSMessageEvent* jsEvent, JSC::ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
const String& typeArg = state.argument(0).toWTFString(&state);
RETURN_IF_EXCEPTION(scope, JSValue());
bool canBubbleArg = state.argument(1).toBoolean(&state);
RETURN_IF_EXCEPTION(scope, JSValue());
bool cancelableArg = state.argument(2).toBoolean(&state);
RETURN_IF_EXCEPTION(scope, JSValue());
JSValue dataArg = state.argument(3);
const String originArg = convert<IDLUSVString>(state, state.argument(4));
RETURN_IF_EXCEPTION(scope, JSValue());
const String lastEventIdArg = state.argument(5).toWTFString(&state);
RETURN_IF_EXCEPTION(scope, JSValue());
auto sourceArg = convert<IDLNullable<IDLUnion<IDLInterface<DOMWindow>, IDLInterface<MessagePort>>>>(state, state.argument(6));
RETURN_IF_EXCEPTION(scope, JSValue());
Vector<RefPtr<MessagePort>> messagePorts;
if (!state.argument(7).isUndefinedOrNull()) {
messagePorts = convert<IDLSequence<IDLInterface<MessagePort>>>(state, state.argument(7));
RETURN_IF_EXCEPTION(scope, JSValue());
}
MessageEvent& event = jsEvent->wrapped();
event.initMessageEvent(state, typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, WTFMove(sourceArg), WTFMove(messagePorts));
jsEvent->m_data.set(vm, jsEvent, dataArg);
return jsUndefined();
}
void WorkerScriptController::setException(JSC::Exception* exception)
{
JSC::ExecState* exec = m_workerGlobalScopeWrapper->globalExec();
exec->vm().throwException(exec, exception);
}
void throwSecurityError(JSC::ExecState& state, const String& message)
{
ASSERT(!state.hadException());
state.vm().throwException(&state, createDOMException(&state, SECURITY_ERR));
}
static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState& state, WebGLRenderingContextBase& context)
{
if (state.argumentCount() != 2)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
WebGLUniformLocation* location = 0;
long index = -1;
if (functionForUniform(f)) {
location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(0));
if (!location && !state.uncheckedArgument(0).isUndefinedOrNull())
return throwTypeError(&state);
} else
index = state.uncheckedArgument(0).toInt32(&state);
if (state.hadException())
return jsUndefined();
RefPtr<Float32Array> webGLArray = toFloat32Array(state.uncheckedArgument(1));
if (state.hadException())
return jsUndefined();
ExceptionCode ec = 0;
if (webGLArray) {
switch (f) {
case f_uniform1v:
context.uniform1fv(location, *webGLArray, ec);
break;
case f_uniform2v:
context.uniform2fv(location, *webGLArray, ec);
break;
case f_uniform3v:
context.uniform3fv(location, *webGLArray, ec);
break;
case f_uniform4v:
context.uniform4fv(location, *webGLArray, ec);
break;
case f_vertexAttrib1v:
context.vertexAttrib1fv(index, *webGLArray);
break;
case f_vertexAttrib2v:
context.vertexAttrib2fv(index, *webGLArray);
break;
case f_vertexAttrib3v:
context.vertexAttrib3fv(index, *webGLArray);
break;
case f_vertexAttrib4v:
context.vertexAttrib4fv(index, *webGLArray);
break;
}
setDOMException(&state, ec);
return jsUndefined();
}
Vector<float, 64> array;
if (!toVector(state, state.uncheckedArgument(1), array))
return throwTypeError(&state);
switch (f) {
case f_uniform1v:
context.uniform1fv(location, array.data(), array.size(), ec);
break;
case f_uniform2v:
context.uniform2fv(location, array.data(), array.size(), ec);
break;
case f_uniform3v:
context.uniform3fv(location, array.data(), array.size(), ec);
break;
case f_uniform4v:
context.uniform4fv(location, array.data(), array.size(), ec);
break;
case f_vertexAttrib1v:
context.vertexAttrib1fv(index, array.data(), array.size());
break;
case f_vertexAttrib2v:
context.vertexAttrib2fv(index, array.data(), array.size());
break;
case f_vertexAttrib3v:
context.vertexAttrib3fv(index, array.data(), array.size());
break;
case f_vertexAttrib4v:
context.vertexAttrib4fv(index, array.data(), array.size());
break;
}
setDOMException(&state, ec);
return jsUndefined();
}