// Custom functions JSValue JSXMLHttpRequest::open(ExecState& state) { if (state.argumentCount() < 2) return state.vm().throwException(&state, createNotEnoughArgumentsError(&state)); const URL& url = wrapped().scriptExecutionContext()->completeURL(state.uncheckedArgument(1).toString(&state)->value(&state)); String method = state.uncheckedArgument(0).toString(&state)->value(&state); ExceptionCode ec = 0; if (state.argumentCount() >= 3) { bool async = state.uncheckedArgument(2).toBoolean(&state); if (!state.argument(3).isUndefined()) { String user = valueToStringWithNullCheck(&state, state.uncheckedArgument(3)); if (!state.argument(4).isUndefined()) { String password = valueToStringWithNullCheck(&state, state.uncheckedArgument(4)); wrapped().open(method, url, async, user, password, ec); } else wrapped().open(method, url, async, user, ec); } else wrapped().open(method, url, async, ec); } else wrapped().open(method, url, ec); setDOMException(&state, ec); return jsUndefined(); }
JSValue JSXSLTProcessor::setParameter(ExecState& state) { if (state.argument(1).isUndefinedOrNull() || state.argument(2).isUndefinedOrNull()) return jsUndefined(); // Throw exception? String namespaceURI = state.uncheckedArgument(0).toString(&state)->value(&state); String localName = state.uncheckedArgument(1).toString(&state)->value(&state); String value = state.uncheckedArgument(2).toString(&state)->value(&state); wrapped().setParameter(namespaceURI, localName, value); return jsUndefined(); }
JSValue JSHTMLInputElement::setSelectionRange(ExecState& state) { HTMLInputElement& input = wrapped(); if (!input.canHaveSelection()) return throwTypeError(&state); int start = state.argument(0).toInt32(&state); int end = state.argument(1).toInt32(&state); String direction = state.argument(2).toString(&state)->value(&state); input.setSelectionRange(start, end, direction); return jsUndefined(); }
JSValue JSXMLHttpRequest::send(ExecState& state) { InspectorInstrumentation::willSendXMLHttpRequest(wrapped().scriptExecutionContext(), wrapped().url()); ExceptionCode ec = 0; JSValue val = state.argument(0); if (val.isUndefinedOrNull()) wrapped().send(ec); else if (val.inherits(JSDocument::info())) wrapped().send(JSDocument::toWrapped(val), ec); else if (val.inherits(JSBlob::info())) wrapped().send(JSBlob::toWrapped(val), ec); else if (val.inherits(JSDOMFormData::info())) wrapped().send(JSDOMFormData::toWrapped(val), ec); else if (val.inherits(JSArrayBuffer::info())) wrapped().send(toArrayBuffer(val), ec); else if (val.inherits(JSArrayBufferView::info())) { RefPtr<ArrayBufferView> view = toArrayBufferView(val); wrapped().send(view.get(), ec); } else wrapped().send(val.toString(&state)->value(&state), ec); // FIXME: This should probably use ShadowChicken so that we get the right frame even when it did // a tail call. // https://bugs.webkit.org/show_bug.cgi?id=155688 SendFunctor functor; state.iterate(functor); wrapped().setLastSendLineAndColumnNumber(functor.line(), functor.column()); wrapped().setLastSendURL(functor.url()); setDOMException(&state, ec); return jsUndefined(); }
static inline void documentWrite(ExecState& state, JSHTMLDocument* thisDocument, NewlineRequirement addNewline) { HTMLDocument* document = &thisDocument->wrapped(); // DOM only specifies single string argument, but browsers allow multiple or no arguments. size_t size = state.argumentCount(); String firstString = state.argument(0).toString(&state)->value(&state); SegmentedString segmentedString = firstString; if (size != 1) { if (!size) segmentedString.clear(); else { for (size_t i = 1; i < size; ++i) { String subsequentString = state.uncheckedArgument(i).toString(&state)->value(&state); segmentedString.append(SegmentedString(subsequentString)); } } } if (addNewline) segmentedString.append(SegmentedString(String(&newlineCharacter, 1))); Document* activeDocument = findCallingDocument(state); document->write(segmentedString, activeDocument); }
JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 2) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); CryptoKeyFormat keyFormat; auto success = cryptoKeyFormatFromJSValue(state, state.argument(0), keyFormat); ASSERT(scope.exception() || success); if (!success) return jsUndefined(); RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(state.uncheckedArgument(1)); if (!key) return throwTypeError(&state, scope); RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable { fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size()); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(nullptr); }; WebCore::exportKey(state, keyFormat, *key, WTFMove(successCallback), WTFMove(failureCallback)); RETURN_IF_EXCEPTION(scope, JSValue()); return promise; }
JSValue JSInspectorFrontendHost::showContextMenu(ExecState& state) { #if ENABLE(CONTEXT_MENUS) if (state.argumentCount() < 2) return jsUndefined(); Event* event = JSEvent::toWrapped(state.argument(0)); JSArray* array = asArray(state.argument(1)); ContextMenu menu; populateContextMenuItems(&state, array, menu); wrapped().showContextMenu(event, menu.items()); #else UNUSED_PARAM(state); #endif return jsUndefined(); }
JSValue JSDeviceMotionEvent::initDeviceMotionEvent(ExecState& state) { const String type = state.argument(0).toString(&state)->value(&state); bool bubbles = state.argument(1).toBoolean(&state); bool cancelable = state.argument(2).toBoolean(&state); // If any of the parameters are null or undefined, mark them as not provided. // Otherwise, use the standard JavaScript conversion. RefPtr<DeviceMotionData::Acceleration> acceleration = readAccelerationArgument(state.argument(3), state); if (state.hadException()) return jsUndefined(); RefPtr<DeviceMotionData::Acceleration> accelerationIncludingGravity = readAccelerationArgument(state.argument(4), state); if (state.hadException()) return jsUndefined(); RefPtr<DeviceMotionData::RotationRate> rotationRate = readRotationRateArgument(state.argument(5), state); if (state.hadException()) return jsUndefined(); bool intervalProvided = !state.argument(6).isUndefinedOrNull(); double interval = state.argument(6).toNumber(&state); RefPtr<DeviceMotionData> deviceMotionData = DeviceMotionData::create(acceleration, accelerationIncludingGravity, rotationRate, intervalProvided, interval); wrapped().initDeviceMotionEvent(type, bubbles, cancelable, deviceMotionData.get()); return jsUndefined(); }
JSValue JSDOMWindow::open(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); String urlString = convert<IDLNullable<IDLUSVString>>(state, state.argument(0)); RETURN_IF_EXCEPTION(scope, JSValue()); JSValue targetValue = state.argument(1); AtomicString target = targetValue.isUndefinedOrNull() ? AtomicString("_blank", AtomicString::ConstructFromLiteral) : targetValue.toString(&state)->toAtomicString(&state); RETURN_IF_EXCEPTION(scope, JSValue()); String windowFeaturesString = convert<IDLNullable<IDLDOMString>>(state, state.argument(2)); RETURN_IF_EXCEPTION(scope, JSValue()); RefPtr<DOMWindow> openedWindow = wrapped().open(urlString, target, windowFeaturesString, activeDOMWindow(&state), firstDOMWindow(&state)); if (!openedWindow) return jsNull(); return toJS(&state, openedWindow.get()); }
inline void DialogHandler::dialogCreated(DOMWindow* dialog) { m_frame = dialog->frame(); // FIXME: This looks like a leak between the normal world and an isolated // world if dialogArguments comes from an isolated world. JSDOMWindow* globalObject = toJSDOMWindow(m_frame.get(), normalWorld(m_exec->globalData())); if (JSValue dialogArguments = m_exec->argument(1)) globalObject->putDirect(m_exec->globalData(), Identifier(m_exec, "dialogArguments"), dialogArguments); }
JSValue JSXSLTProcessor::removeParameter(ExecState& state) { if (state.argument(1).isUndefinedOrNull()) return jsUndefined(); String namespaceURI = state.uncheckedArgument(0).toString(&state)->value(&state); String localName = state.uncheckedArgument(1).toString(&state)->value(&state); wrapped().removeParameter(namespaceURI, localName); return jsUndefined(); }
JSValue JSWorkerGlobalScope::setInterval(ExecState& state) { std::unique_ptr<ScheduledAction> action = ScheduledAction::create(&state, globalObject()->world(), wrapped().contentSecurityPolicy()); if (state.hadException()) return jsUndefined(); if (!action) return jsNumber(0); int delay = state.argument(1).toInt32(&state); return jsNumber(wrapped().setInterval(WTFMove(action), delay)); }
JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 1) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto algorithm = createAlgorithmFromJSValue(state, state.uncheckedArgument(0)); ASSERT(scope.exception() || algorithm); if (!algorithm) return jsUndefined(); auto parameters = JSCryptoAlgorithmDictionary::createParametersForGenerateKey(&state, algorithm->identifier(), state.uncheckedArgument(0)); ASSERT(scope.exception() || parameters); if (!parameters) return jsUndefined(); bool extractable = false; if (state.argumentCount() >= 2) { extractable = state.uncheckedArgument(1).toBoolean(&state); RETURN_IF_EXCEPTION(scope, JSValue()); } CryptoKeyUsageBitmap keyUsages = 0; if (state.argumentCount() >= 3) { auto success = cryptoKeyUsagesFromJSValue(state, state.argument(2), keyUsages); ASSERT(scope.exception() || success); if (!success) return jsUndefined(); } RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable { ASSERT(key || keyPair); ASSERT(!key || !keyPair); if (key) wrapper->resolve(key); else wrapper->resolve(keyPair); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(nullptr); }; auto result = algorithm->generateKey(*parameters, extractable, keyUsages, WTFMove(successCallback), WTFMove(failureCallback), *scriptExecutionContextFromExecState(&state)); if (result.hasException()) { propagateException(state, scope, result.releaseException()); return { }; } return promise; }
RefPtr<ReadableJSStream> ReadableJSStream::create(ExecState& state, ScriptExecutionContext& scriptExecutionContext) { // FIXME: We should consider reducing the binding code herei (using Dictionary/regular binding constructor and/or improving the IDL generator). JSObject* jsSource; JSValue value = state.argument(0); if (value.isObject()) jsSource = value.getObject(); else if (!value.isUndefined()) { throwVMError(&state, createTypeError(&state, ASCIILiteral("First argument, if any, should be an object"))); return nullptr; } else jsSource = JSFinalObject::create(state.vm(), JSFinalObject::createStructure(state.vm(), state.callee()->globalObject(), jsNull(), 1)); double highWaterMark = 1; JSFunction* sizeFunction = nullptr; value = state.argument(1); if (value.isObject()) { JSObject& strategyObject = *value.getObject(); highWaterMark = normalizeHighWaterMark(state, strategyObject); if (state.hadException()) return nullptr; if (!(sizeFunction = jsDynamicCast<JSFunction*>(getPropertyFromObject(state, strategyObject, "size")))) { if (!state.hadException()) throwVMError(&state, createTypeError(&state, ASCIILiteral("size parameter should be a function"))); return nullptr; } } else if (!value.isUndefined()) { throwVMError(&state, createTypeError(&state, ASCIILiteral("Second argument, if any, should be an object"))); return nullptr; } RefPtr<ReadableJSStream> readableStream = adoptRef(*new ReadableJSStream(scriptExecutionContext, state, jsSource, highWaterMark, sizeFunction)); readableStream->doStart(state); if (state.hadException()) return nullptr; return readableStream; }
JSValue JSDOMWindow::showModalDialog(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (UNLIKELY(state.argumentCount() < 1)) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); String urlString = convert<IDLNullable<IDLDOMString>>(state, state.argument(0)); RETURN_IF_EXCEPTION(scope, JSValue()); String dialogFeaturesString = convert<IDLNullable<IDLDOMString>>(state, state.argument(2)); RETURN_IF_EXCEPTION(scope, JSValue()); DialogHandler handler(state); wrapped().showModalDialog(urlString, dialogFeaturesString, activeDOMWindow(&state), firstDOMWindow(&state), [&handler](DOMWindow& dialog) { handler.dialogCreated(dialog); }); return handler.returnValue(); }
JSValue JSInspectorFrontendHost::showContextMenu(ExecState& state) { #if ENABLE(CONTEXT_MENUS) if (state.argumentCount() < 2) return jsUndefined(); Event* event = JSEvent::toWrapped(state.argument(0)); JSArray* array = asArray(state.argument(1)); ContextMenu menu; populateContextMenuItems(&state, array, menu); #if !USE(CROSS_PLATFORM_CONTEXT_MENUS) Vector<ContextMenuItem> items = contextMenuItemVector(menu.platformDescription()); #else Vector<ContextMenuItem> items = menu.items(); #endif wrapped().showContextMenu(event, items); #else UNUSED_PARAM(state); #endif return jsUndefined(); }
ReadableJSStream::ReadableJSStream(ScriptExecutionContext& scriptExecutionContext, ExecState& state, JSObject* source, double highWaterMark, JSFunction* sizeFunction) : ReadableStream(scriptExecutionContext) , m_highWaterMark(highWaterMark) { m_source.set(state.vm(), source); // We do not take a Ref to the stream as this would cause a Ref cycle. // The resolution callback used jointly with m_errorFunction as promise callbacks should protect the stream instead. m_errorFunction.set(state.vm(), JSFunction::create(state.vm(), state.callee()->globalObject(), 1, String(), [this](ExecState* state) { storeError(*state, state->argument(0)); return JSValue::encode(jsUndefined()); })); if (sizeFunction) m_sizeFunction.set(state.vm(), sizeFunction); }
JSValue JSNode::removeChild(ExecState& state) { JSValue childValue = state.argument(0); auto* child = JSNode::toWrapped(childValue); if (UNLIKELY(!child)) return JSValue::decode(throwArgumentTypeError(state, 0, "child", "Node", "removeChild", "Node")); ExceptionCode ec = 0; if (UNLIKELY(!wrapped().removeChild(*child, ec))) { setDOMException(&state, ec); return jsUndefined(); } ASSERT(!ec); return childValue; }
JSValue JSNode::appendChild(ExecState& state) { JSValue newChildValue = state.argument(0); auto newChild = JSNode::toWrapped(newChildValue); if (UNLIKELY(!newChild)) return JSValue::decode(throwArgumentTypeError(state, 0, "node", "Node", "appendChild", "Node")); ExceptionCode ec = 0; if (UNLIKELY(!wrapped().appendChild(*newChild, ec))) { setDOMException(&state, ec); return jsUndefined(); } ASSERT(!ec); return newChildValue; }
JSValue JSWorkerGlobalScope::setInterval(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (UNLIKELY(state.argumentCount() < 1)) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); std::unique_ptr<ScheduledAction> action = ScheduledAction::create(&state, globalObject()->world(), wrapped().contentSecurityPolicy()); if (state.hadException()) return jsUndefined(); if (!action) return jsNumber(0); int delay = state.argument(1).toInt32(&state); return jsNumber(wrapped().setInterval(WTFMove(action), delay)); }
JSValue JSWebKitSubtleCrypto::importKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 3) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto keyFormat = cryptoKeyFormatFromJSValue(state, scope, state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); auto data = cryptoOperationDataFromJSValue(state, scope, state.uncheckedArgument(1)); RETURN_IF_EXCEPTION(scope, { }); RefPtr<CryptoAlgorithm> algorithm; RefPtr<CryptoAlgorithmParametersDeprecated> parameters; if (!state.uncheckedArgument(2).isNull()) { algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(2)); RETURN_IF_EXCEPTION(scope, { }); parameters = JSCryptoAlgorithmDictionary::createParametersForImportKey(state, scope, algorithm->identifier(), state.uncheckedArgument(2)); RETURN_IF_EXCEPTION(scope, { }); } bool extractable = state.argument(3).toBoolean(&state); RETURN_IF_EXCEPTION(scope, JSValue()); CryptoKeyUsageBitmap keyUsages = 0; if (state.argumentCount() >= 5) { keyUsages = cryptoKeyUsagesFromJSValue(state, scope, state.uncheckedArgument(4)); RETURN_IF_EXCEPTION(scope, { }); } RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](CryptoKey& result) mutable { wrapper->resolve<IDLInterface<CryptoKey>>(result); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(); // FIXME: This should reject with an Exception. }; WebCore::importKey(state, keyFormat, data, WTFMove(algorithm), WTFMove(parameters), extractable, keyUsages, WTFMove(successCallback), WTFMove(failureCallback)); RETURN_IF_EXCEPTION(scope, JSValue()); return promise; }
JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 1) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); auto parameters = JSCryptoAlgorithmDictionary::createParametersForGenerateKey(state, scope, algorithm->identifier(), state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); bool extractable = state.argument(1).toBoolean(&state); RETURN_IF_EXCEPTION(scope, { }); CryptoKeyUsageBitmap keyUsages = 0; if (state.argumentCount() >= 3) { keyUsages = cryptoKeyUsagesFromJSValue(state, scope, state.uncheckedArgument(2)); RETURN_IF_EXCEPTION(scope, { }); } RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](KeyOrKeyPair&& keyOrKeyPair) mutable { WTF::switchOn(keyOrKeyPair, [&wrapper] (RefPtr<CryptoKey>& key) { wrapper->resolve<IDLInterface<CryptoKey>>(*key); }, [&wrapper] (CryptoKeyPair& keyPair) { wrapper->resolve<IDLDictionary<CryptoKeyPair>>(keyPair); } ); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(); // FIXME: This should reject with an Exception. }; auto result = algorithm->generateKey(*parameters, extractable, keyUsages, WTFMove(successCallback), WTFMove(failureCallback), *scriptExecutionContextFromExecState(&state)); if (result.hasException()) { propagateException(state, scope, result.releaseException()); return { }; } return promise; }
JSValue JSDOMWindow::setInterval(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (UNLIKELY(state.argumentCount() < 1)) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto* contentSecurityPolicy = wrapped().document() ? wrapped().document()->contentSecurityPolicy() : nullptr; auto action = ScheduledAction::create(&state, globalObject()->world(), contentSecurityPolicy); RETURN_IF_EXCEPTION(scope, JSValue()); if (!action) return jsNumber(0); int delay = state.argument(1).toInt32(&state); return toJS<IDLLong>(state, scope, wrapped().setInterval(WTFMove(action), delay)); }
JSValue JSHTMLCanvasElement::toDataURL(ExecState& state) { HTMLCanvasElement& canvas = wrapped(); ExceptionCode ec = 0; const String& type = valueToStringWithUndefinedOrNullCheck(&state, state.argument(0)); double quality; double* qualityPtr = 0; if (state.argumentCount() > 1) { JSValue v = state.uncheckedArgument(1); if (v.isNumber()) { quality = v.toNumber(&state); qualityPtr = &quality; } } JSValue result = JSC::jsString(&state, canvas.toDataURL(type, qualityPtr, ec)); setDOMException(&state, ec); return result; }
static void get3DContextAttributes(ExecState& state, RefPtr<CanvasContextAttributes>& attrs) { JSValue initializerValue = state.argument(1); if (initializerValue.isUndefinedOrNull()) return; JSObject* initializerObject = initializerValue.toObject(&state); ASSERT(!state.hadException()); JSDictionary dictionary(&state, initializerObject); GraphicsContext3D::Attributes graphicsAttrs; dictionary.tryGetProperty("alpha", graphicsAttrs.alpha); dictionary.tryGetProperty("depth", graphicsAttrs.depth); dictionary.tryGetProperty("stencil", graphicsAttrs.stencil); dictionary.tryGetProperty("antialias", graphicsAttrs.antialias); dictionary.tryGetProperty("premultipliedAlpha", graphicsAttrs.premultipliedAlpha); dictionary.tryGetProperty("preserveDrawingBuffer", graphicsAttrs.preserveDrawingBuffer); attrs = WebGLContextAttributes::create(graphicsAttrs); }
JSValue JSGeolocation::getCurrentPosition(ExecState& state) { // Arguments: PositionCallback, (optional)PositionErrorCallback, (optional)PositionOptions auto positionCallback = createFunctionOnlyCallback<JSPositionCallback>(&state, globalObject(), state.argument(0)); if (state.hadException()) return jsUndefined(); ASSERT(positionCallback); auto positionErrorCallback = createFunctionOnlyCallback<JSPositionErrorCallback>(&state, globalObject(), state.argument(1), CallbackAllowUndefined | CallbackAllowNull); if (state.hadException()) return jsUndefined(); auto positionOptions = createPositionOptions(&state, state.argument(2)); if (state.hadException()) return jsUndefined(); ASSERT(positionOptions); wrapped().getCurrentPosition(WTFMove(positionCallback), WTFMove(positionErrorCallback), WTFMove(positionOptions)); return jsUndefined(); }
static JSValue handlePostMessage(DOMWindow& impl, ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (UNLIKELY(state.argumentCount() < 2)) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); Vector<RefPtr<MessagePort>> messagePorts; Vector<RefPtr<JSC::ArrayBuffer>> arrayBuffers; // This function has variable arguments and can be: // Per current spec: // postMessage(message, targetOrigin) // postMessage(message, targetOrigin, {sequence of transferrables}) // Legacy non-standard implementations in webkit allowed: // postMessage(message, {sequence of transferrables}, targetOrigin); int targetOriginArgIndex = 1; if (state.argumentCount() > 2) { int transferablesArgIndex = 2; if (state.uncheckedArgument(2).isString()) { targetOriginArgIndex = 2; transferablesArgIndex = 1; } extractTransferables(state, state.argument(transferablesArgIndex), messagePorts, arrayBuffers); } RETURN_IF_EXCEPTION(scope, JSValue()); auto message = SerializedScriptValue::create(state, state.uncheckedArgument(0), messagePorts, WTFMove(arrayBuffers)); RETURN_IF_EXCEPTION(scope, JSValue()); String targetOrigin = convert<IDLNullable<IDLUSVString>>(state, state.uncheckedArgument(targetOriginArgIndex)); RETURN_IF_EXCEPTION(scope, JSValue()); propagateException(state, scope, impl.postMessage(message.releaseNonNull(), WTFMove(messagePorts), targetOrigin, callerDOMWindow(&state))); return jsUndefined(); }
void ReadableJSStream::enqueue(ExecState& state) { ASSERT(!isCloseRequested()); if (!isReadable()) return; JSValue chunk = state.argument(0); if (resolveReadCallback(chunk)) { pull(); return; } double size = retrieveChunkSize(state, chunk); if (state.hadException()) { storeError(state, state.exception()->value()); return; } m_chunkQueue.append({ JSC::Strong<JSC::Unknown>(state.vm(), chunk), size }); m_totalQueueSize += size; pull(); }
JSValue JSHTMLAllCollection::namedItem(ExecState& state) { JSValue value = namedItems(state, this, Identifier::fromString(&state, state.argument(0).toString(&state)->value(&state))); return value.isUndefined() ? jsNull() : value; }
JSValue JSHTMLAllCollection::item(ExecState& state) { if (Optional<uint32_t> index = parseIndex(*state.argument(0).toString(&state)->value(&state).impl())) return toJS(&state, globalObject(), impl().item(index.value())); return namedItems(state, this, Identifier::fromString(&state, state.argument(0).toString(&state)->value(&state))); }