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.")); }