// 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)));
}
