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));
}
void QWebFrameAdapter::addToJavaScriptWindowObject(const QString& name, QObject* object, ValueOwnership ownership)
{
if (!pageAdapter->settings->testAttribute(QWebSettings::JavascriptEnabled))
return;
JSC::Bindings::QtInstance::ValueOwnership valueOwnership = static_cast<JSC::Bindings::QtInstance::ValueOwnership>(ownership);
JSDOMWindow* window = toJSDOMWindow(frame, mainThreadNormalWorld());
JSC::Bindings::RootObject* root;
if (valueOwnership == JSC::Bindings::QtInstance::QtOwnership)
root = frame->script()->cacheableBindingRootObject();
else
root = frame->script()->bindingRootObject();
if (!window) {
qDebug() << "Warning: couldn't get window object";
return;
}
if (!root) {
qDebug() << "Warning: couldn't get root object";
return;
}
JSC::ExecState* exec = window->globalExec();
JSC::JSLockHolder lock(exec);
JSC::JSObject* runtimeObject = JSC::Bindings::QtInstance::getQtInstance(object, root, valueOwnership)->createRuntimeObject(exec);
JSC::PutPropertySlot slot;
window->methodTable()->put(window, exec, JSC::Identifier(&exec->globalData(), reinterpret_cast_ptr<const UChar*>(name.constData()), name.length()), runtimeObject, slot);
}
void willCreatePossiblyOrphanedTreeByRemovalSlowCase(Node* root)
{
JSC::ExecState* scriptState = mainWorldExecState(root->document().frame());
if (!scriptState)
return;
JSLockHolder lock(scriptState);
toJS(scriptState, static_cast<JSDOMGlobalObject*>(scriptState->lexicalGlobalObject()), root);
}
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 HTMLPlugInImageElement::didAddUserAgentShadowRoot(ShadowRoot* root)
{
HTMLPlugInElement::didAddUserAgentShadowRoot(root);
if (displayState() >= PreparingPluginReplacement)
return;
Page* page = document().page();
if (!page)
return;
// Reset any author styles that may apply as we only want explicit
// styles defined in the injected user agents stylesheets to specify
// the look-and-feel of the snapshotted plug-in overlay.
root->setResetStyleInheritance(true);
String mimeType = loadedMimeType();
DOMWrapperWorld& isolatedWorld = plugInImageElementIsolatedWorld();
document().ensurePlugInsInjectedScript(isolatedWorld);
ScriptController& scriptController = document().frame()->script();
JSDOMGlobalObject* globalObject = JSC::jsCast<JSDOMGlobalObject*>(scriptController.globalObject(isolatedWorld));
JSC::ExecState* exec = globalObject->globalExec();
JSC::JSLockHolder lock(exec);
JSC::MarkedArgumentBuffer argList;
argList.append(toJS(exec, globalObject, root));
argList.append(jsString(exec, titleText(page, mimeType)));
argList.append(jsString(exec, subtitleText(page, mimeType)));
// This parameter determines whether or not the snapshot overlay should always be visible over the plugin snapshot.
// If no snapshot was found then we want the overlay to be visible.
argList.append(JSC::jsBoolean(!m_snapshotImage));
// It is expected the JS file provides a createOverlay(shadowRoot, title, subtitle) function.
JSC::JSObject* overlay = globalObject->get(exec, JSC::Identifier::fromString(exec, "createOverlay")).toObject(exec);
if (!overlay) {
ASSERT(exec->hadException());
exec->clearException();
return;
}
JSC::CallData callData;
JSC::CallType callType = overlay->methodTable()->getCallData(overlay, callData);
if (callType == JSC::CallType::None)
return;
JSC::call(exec, overlay, callType, callData, globalObject, argList);
exec->clearException();
}
void InjectedBundle::reportException(JSContextRef context, JSValueRef exception)
{
if (!context || !exception)
return;
JSLock lock(JSC::SilenceAssertionsOnly);
JSC::ExecState* execState = toJS(context);
// Make sure the context has a DOMWindow global object, otherwise this context didn't originate from a Page.
if (!toJSDOMWindow(execState->lexicalGlobalObject()))
return;
WebCore::reportException(execState, toJS(execState, exception));
}
bool injectIDBKeyIntoScriptValue(JSC::ExecState& exec, const IDBKeyData& keyData, JSC::JSValue value, const IDBKeyPath& keyPath)
{
LOG(IndexedDB, "injectIDBKeyIntoScriptValue");
ASSERT(keyPath.type() == IndexedDB::KeyPathType::String);
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath.string(), keyPathElements, error);
ASSERT(error == IDBKeyPathParseError::None);
if (keyPathElements.isEmpty())
return false;
JSValue parent = ensureNthValueOnKeyPath(&exec, value, keyPathElements, keyPathElements.size() - 1);
if (parent.isUndefined())
return false;
auto key = keyData.maybeCreateIDBKey();
if (!key)
return false;
if (!set(&exec, parent, keyPathElements.last(), idbKeyToJSValue(&exec, exec.lexicalGlobalObject(), key.get())))
return false;
return true;
}
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();
}
void ReadableJSStream::storeError(JSC::ExecState& exec, JSValue error)
{
if (m_error)
return;
m_error.set(exec.vm(), error);
changeStateToErrored();
}
static JSValue idbValueDataToJSValue(JSC::ExecState& exec, const Vector<uint8_t>& buffer)
{
if (buffer.isEmpty())
return jsNull();
RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::createFromWireBytes(buffer);
return serializedValue->deserialize(&exec, exec.lexicalGlobalObject(), 0, NonThrowing);
}
void ReadableJSStream::error(JSC::ExecState& state, ExceptionCode& ec)
{
if (!isReadable()) {
ec = TypeError;
return;
}
storeError(state, state.argument(0));
}
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(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());
}
void fillMessagePortArray(JSC::ExecState& state, JSC::JSValue value, MessagePortArray& portArray, ArrayBufferArray& arrayBuffers)
{
// Convert from the passed-in JS array-like object to a MessagePortArray.
// Also validates the elements per sections 4.1.13 and 4.1.15 of the WebIDL spec and section 8.3.3 of the HTML5 spec.
if (value.isUndefinedOrNull()) {
portArray.resize(0);
arrayBuffers.resize(0);
return;
}
// Validation of sequence types, per WebIDL spec 4.1.13.
unsigned length = 0;
JSObject* object = toJSSequence(state, value, length);
if (state.hadException())
return;
for (unsigned i = 0 ; i < length; ++i) {
JSValue value = object->get(&state, i);
if (state.hadException())
return;
// Validation of non-null objects, per HTML5 spec 10.3.3.
if (value.isUndefinedOrNull()) {
setDOMException(&state, INVALID_STATE_ERR);
return;
}
// Validation of Objects implementing an interface, per WebIDL spec 4.1.15.
if (RefPtr<MessagePort> port = JSMessagePort::toWrapped(value)) {
// Check for duplicate ports.
if (portArray.contains(port)) {
setDOMException(&state, INVALID_STATE_ERR);
return;
}
portArray.append(WTFMove(port));
} else {
if (RefPtr<ArrayBuffer> arrayBuffer = toArrayBuffer(value))
arrayBuffers.append(WTFMove(arrayBuffer));
else {
throwTypeError(&state);
return;
}
}
}
}
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 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;
}
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;
}
JSType JSValueGetType(JSContextRef ctx, JSValueRef value)
{
JSC::ExecState* exec = toJS(ctx);
exec->globalData().heap.registerThread();
JSC::JSLock lock(exec);
JSC::JSValue jsValue = toJS(exec, value);
if (jsValue.isUndefined())
return kJSTypeUndefined;
if (jsValue.isNull())
return kJSTypeNull;
if (jsValue.isBoolean())
return kJSTypeBoolean;
if (jsValue.isNumber())
return kJSTypeNumber;
if (jsValue.isString())
return kJSTypeString;
ASSERT(jsValue.isObject());
return kJSTypeObject;
}
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 DragData::asFilenames(Vector<String>& result) const
{
bool success;
JSC::JSValue data = m_platformDragData->getData(ClipboardApolloHelper::FILE_LIST_TYPE, success);
JSC::ExecState *exec = m_platformDragData->execState();
if (success && data.isObject()) {
JSC::JSObject* filenameArray = data.toObject(exec);
uint32_t length = filenameArray->get(exec, JSC::Identifier(exec, "length")).toUInt32(exec);
for (uint32_t i=0; i<length; i++) {
JSC::JSValue fileValue = filenameArray->get(exec, i);
if (fileValue.isObject()) {
JSC::JSObject* file = fileValue.toObject(exec);
JSC::JSValue pathValue = file->get(exec, JSC::Identifier(exec, "nativePath"));
if (pathValue.isString()) {
String path = ustringToString(pathValue.toString(exec));
result.append(path);
}
}
}
}
if (exec->hadException())
exec->clearException();
}
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);
}
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();
}
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;
}
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);
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::putOrAdd(JSC::ExecState& state, JSC::JSValue value, RefPtr<IDBKey> key, IndexedDB::ObjectStoreOverwriteMode overwriteMode, ExceptionCode& ec)
{
LOG(IndexedDB, "IDBObjectStore::putOrAdd");
if (m_transaction->isReadOnly()) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::ReadOnlyError);
return nullptr;
}
if (!m_transaction->isActive()) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::TransactionInactiveError);
return nullptr;
}
if (m_deleted) {
ec = INVALID_STATE_ERR;
return nullptr;
}
RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::create(&state, value, nullptr, nullptr);
if (state.hadException()) {
ec = DATA_CLONE_ERR;
return nullptr;
}
if (serializedValue->hasBlobURLs()) {
// FIXME: Add Blob/File/FileList support
ec = DATA_CLONE_ERR;
return nullptr;
}
if (key && key->type() == KeyType::Invalid) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
bool usesInlineKeys = !m_info.keyPath().isNull();
bool usesKeyGenerator = autoIncrement();
if (usesInlineKeys) {
if (key) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
RefPtr<IDBKey> keyPathKey = maybeCreateIDBKeyFromScriptValueAndKeyPath(state, value, m_info.keyPath());
if (keyPathKey && !keyPathKey->isValid()) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
if (!keyPathKey) {
if (usesKeyGenerator) {
if (!canInjectIDBKeyIntoScriptValue(state, value, m_info.keyPath())) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
} else {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
}
if (keyPathKey) {
ASSERT(!key);
key = keyPathKey;
}
} else if (!usesKeyGenerator && !key) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
auto context = scriptExecutionContextFromExecState(&state);
if (!context) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::Unknown);
return nullptr;
}
Ref<IDBRequest> request = m_transaction->requestPutOrAdd(*context, *this, key.get(), *serializedValue, overwriteMode);
return adoptRef(request.leakRef());
}
JSC::EncodedJSValue reportDeprecatedGetterError(JSC::ExecState& state, const char* interfaceName, const char* attributeName)
{
auto& context = *jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject())->scriptExecutionContext();
context.addConsoleMessage(MessageSource::JS, MessageLevel::Error, makeString("Deprecated attempt to access property '", attributeName, "' on a non-", interfaceName, " object."));
return JSValue::encode(jsUndefined());
}
void ReadableJSStream::storeException(JSC::ExecState& state)
{
JSValue exception = state.exception()->value();
state.clearException();
storeError(state, exception);
}
void reportDeprecatedSetterError(JSC::ExecState& state, const char* interfaceName, const char* attributeName)
{
auto& context = *jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject())->scriptExecutionContext();
context.addConsoleMessage(MessageSource::JS, MessageLevel::Error, makeString("Deprecated attempt to set property '", attributeName, "' on a non-", interfaceName, " object."));
}