JSValue JSWebKitSubtleCrypto::digest(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (state.argumentCount() < 2)
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(0));
RETURN_IF_EXCEPTION(scope, { });
auto parameters = JSCryptoAlgorithmDictionary::createParametersForDigest(state, scope, algorithm->identifier(), state.uncheckedArgument(0));
RETURN_IF_EXCEPTION(scope, { });
auto data = cryptoOperationDataFromJSValue(state, scope, state.uncheckedArgument(1));
RETURN_IF_EXCEPTION(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(); // FIXME: This should reject with an Exception.
};
auto result = algorithm->digest(*parameters, data, WTFMove(successCallback), WTFMove(failureCallback));
if (result.hasException()) {
propagateException(state, scope, result.releaseException());
return { };
}
return promise;
}
// 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 JSWebKitSubtleCrypto::exportKey(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (state.argumentCount() < 2)
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto keyFormat = cryptoKeyFormatFromJSValue(state, scope, state.uncheckedArgument(0));
RETURN_IF_EXCEPTION(scope, { });
RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(vm, 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(); // FIXME: This should reject with an Exception.
};
WebCore::exportKey(state, keyFormat, *key, WTFMove(successCallback), WTFMove(failureCallback));
RETURN_IF_EXCEPTION(scope, JSValue());
return promise;
}
JSValue JSCommandLineAPIHost::inspect(ExecState& state)
{
if (state.argumentCount() < 2)
return jsUndefined();
wrapped().inspectImpl(Inspector::toInspectorValue(state, state.uncheckedArgument(0)),
Inspector::toInspectorValue(state, state.uncheckedArgument(1)));
return jsUndefined();
}
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 JSWebKitSubtleCrypto::verify(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (state.argumentCount() < 4)
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto algorithm = createAlgorithmFromJSValue(state, state.uncheckedArgument(0));
ASSERT(scope.exception() || algorithm);
if (!algorithm)
return jsUndefined();
auto parameters = JSCryptoAlgorithmDictionary::createParametersForVerify(&state, algorithm->identifier(), state.uncheckedArgument(0));
ASSERT(scope.exception() || parameters);
if (!parameters)
return jsUndefined();
RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(state.uncheckedArgument(1));
if (!key)
return throwTypeError(&state, scope);
if (!key->allows(CryptoKeyUsageVerify)) {
wrapped().document()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("Key usages do not include 'verify'"));
setDOMException(&state, NOT_SUPPORTED_ERR);
return jsUndefined();
}
CryptoOperationData signature;
auto success = cryptoOperationDataFromJSValue(&state, state.uncheckedArgument(2), signature);
ASSERT(scope.exception() || success);
if (!success)
return jsUndefined();
CryptoOperationData data;
success = cryptoOperationDataFromJSValue(&state, state.uncheckedArgument(3), data);
ASSERT(scope.exception() || success);
if (!success)
return jsUndefined();
RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
auto promise = wrapper->promise();
auto successCallback = [wrapper](bool result) mutable {
wrapper->resolve(result);
};
auto failureCallback = [wrapper]() mutable {
wrapper->reject(nullptr);
};
auto result = algorithm->verify(*parameters, *key, signature, data, WTFMove(successCallback), WTFMove(failureCallback));
if (result.hasException()) {
propagateException(state, scope, result.releaseException());
return { };
}
return promise;
}
JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (state.argumentCount() < 4)
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto keyFormat = cryptoKeyFormatFromJSValue(state, scope, state.uncheckedArgument(0));
RETURN_IF_EXCEPTION(scope, { });
RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(vm, state.uncheckedArgument(1));
if (!key)
return throwTypeError(&state, scope);
RefPtr<CryptoKey> wrappingKey = JSCryptoKey::toWrapped(vm, state.uncheckedArgument(2));
if (!key)
return throwTypeError(&state, scope);
if (!wrappingKey->allows(CryptoKeyUsageWrapKey)) {
wrapped().document()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("Key usages do not include 'wrapKey'"));
throwNotSupportedError(state, scope);
return jsUndefined();
}
auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(3));
RETURN_IF_EXCEPTION(scope, { });
auto parameters = JSCryptoAlgorithmDictionary::createParametersForEncrypt(state, scope, algorithm->identifier(), state.uncheckedArgument(3));
RETURN_IF_EXCEPTION(scope, { });
RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
auto promise = wrapper->promise();
auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {
auto encryptSuccessCallback = [wrapper](const Vector<uint8_t>& encryptedData) mutable {
fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), encryptedData.data(), encryptedData.size());
};
auto encryptFailureCallback = [wrapper]() mutable {
wrapper->reject(); // FIXME: This should reject with an Exception.
};
auto result = algorithm->encryptForWrapKey(*parameters, *wrappingKey, std::make_pair(exportedKeyData.data(), exportedKeyData.size()), WTFMove(encryptSuccessCallback), WTFMove(encryptFailureCallback));
if (result.hasException()) {
// FIXME: Report failure details to console, and possibly to calling script once there is a standardized way to pass errors to WebCrypto promise reject functions.
wrapper->reject(); // FIXME: This should reject with an Exception.
}
};
auto exportFailureCallback = [wrapper]() mutable {
wrapper->reject(); // FIXME: This should reject with an Exception.
};
WebCore::exportKey(state, keyFormat, *key, WTFMove(exportSuccessCallback), WTFMove(exportFailureCallback));
return promise;
}
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 JSCommandLineAPIHost::inspect(ExecState& state)
{
if (state.argumentCount() >= 2) {
Deprecated::ScriptValue object(state.vm(), state.uncheckedArgument(0));
Deprecated::ScriptValue hints(state.vm(), state.uncheckedArgument(1));
wrapped().inspectImpl(object.toInspectorValue(&state), hints.toInspectorValue(&state));
}
return jsUndefined();
}
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;
}
EncodedJSValue JSC_HOST_CALL constructJSWorker(ExecState& exec)
{
VM& vm = exec.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
DOMConstructorObject* jsConstructor = jsCast<DOMConstructorObject*>(exec.callee());
if (!exec.argumentCount())
return throwVMError(&exec, scope, createNotEnoughArgumentsError(&exec));
String scriptURL = exec.uncheckedArgument(0).toWTFString(&exec);
if (exec.hadException())
return JSValue::encode(JSValue());
// See section 4.8.2 step 14 of WebWorkers for why this is the lexicalGlobalObject.
DOMWindow& window = asJSDOMWindow(exec.lexicalGlobalObject())->wrapped();
ExceptionCode ec = 0;
ASSERT(window.document());
RefPtr<Worker> worker = Worker::create(*window.document(), scriptURL, ec);
if (ec) {
setDOMException(&exec, ec);
return JSValue::encode(JSValue());
}
return JSValue::encode(toJSNewlyCreated(&exec, jsConstructor->globalObject(), WTFMove(worker)));
}
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 JSCommandLineAPIHost::getEventListeners(ExecState& state)
{
if (state.argumentCount() < 1)
return jsUndefined();
JSValue value = state.uncheckedArgument(0);
if (!value.isObject() || value.isNull())
return jsUndefined();
Node* node = JSNode::toWrapped(value);
if (!node)
return jsUndefined();
Vector<EventListenerInfo> listenersArray;
wrapped().getEventListenersImpl(node, listenersArray);
JSObject* result = constructEmptyObject(&state);
for (size_t i = 0; i < listenersArray.size(); ++i) {
JSArray* listeners = getJSListenerFunctions(state, &node->document(), listenersArray[i]);
if (!listeners->length())
continue;
AtomicString eventType = listenersArray[i].eventType;
result->putDirect(state.vm(), Identifier::fromString(&state, eventType.impl()), JSValue(listeners));
}
return result;
}
JSValue JSWebKitSubtleCrypto::verify(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (state.argumentCount() < 4)
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(0));
RETURN_IF_EXCEPTION(scope, { });
auto parameters = JSCryptoAlgorithmDictionary::createParametersForVerify(state, scope, algorithm->identifier(), state.uncheckedArgument(0));
RETURN_IF_EXCEPTION(scope, { });
RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(vm, state.uncheckedArgument(1));
if (!key)
return throwTypeError(&state, scope);
if (!key->allows(CryptoKeyUsageVerify)) {
wrapped().document()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("Key usages do not include 'verify'"));
throwNotSupportedError(state, scope);
return jsUndefined();
}
auto signature = cryptoOperationDataFromJSValue(state, scope, state.uncheckedArgument(2));
RETURN_IF_EXCEPTION(scope, { });
auto data = cryptoOperationDataFromJSValue(state, scope, state.uncheckedArgument(3));
RETURN_IF_EXCEPTION(scope, { });
RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
auto promise = wrapper->promise();
auto successCallback = [wrapper](bool result) mutable {
wrapper->resolve<IDLBoolean>(result);
};
auto failureCallback = [wrapper]() mutable {
wrapper->reject(); // FIXME: This should reject with an Exception.
};
auto result = algorithm->verify(*parameters, *key, signature, data, WTFMove(successCallback), WTFMove(failureCallback));
if (result.hasException()) {
propagateException(state, scope, result.releaseException());
return { };
}
return promise;
}
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 JSWebGL2RenderingContext::getIndexedParameter(ExecState& exec)
{
VM& vm = exec.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (exec.argumentCount() != 2)
return throwException(&exec, scope, createNotEnoughArgumentsError(&exec));
WebGL2RenderingContext& context = wrapped();
unsigned pname = exec.uncheckedArgument(0).toInt32(&exec);
if (exec.hadException())
return jsUndefined();
unsigned index = exec.uncheckedArgument(1).toInt32(&exec);
if (exec.hadException())
return jsUndefined();
WebGLGetInfo info = context.getIndexedParameter(pname, index);
return toJS(&exec, globalObject(), info);
}
JSValue JSNode::insertBefore(ExecState& state)
{
if (UNLIKELY(state.argumentCount() < 2))
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
JSValue newChildValue = state.uncheckedArgument(0);
auto* newChild = JSNode::toWrapped(newChildValue);
if (UNLIKELY(!newChild))
return JSValue::decode(throwArgumentTypeError(state, 0, "node", "Node", "insertBefore", "Node"));
ExceptionCode ec = 0;
if (UNLIKELY(!wrapped().insertBefore(*newChild, JSNode::toWrapped(state.uncheckedArgument(1)), ec))) {
setDOMException(&state, ec);
return jsUndefined();
}
ASSERT(!ec);
return newChildValue;
}
JSValue JSCommandLineAPIHost::storageId(ExecState& state)
{
if (state.argumentCount() < 1)
return jsUndefined();
Storage* storage = JSStorage::toWrapped(state.uncheckedArgument(0));
if (storage)
return jsStringWithCache(&state, wrapped().storageIdImpl(storage));
return jsUndefined();
}
JSValue JSCommandLineAPIHost::databaseId(ExecState& state)
{
if (state.argumentCount() < 1)
return jsUndefined();
Database* database = JSDatabase::toWrapped(state.uncheckedArgument(0));
if (database)
return jsStringWithCache(&state, wrapped().databaseIdImpl(database));
return jsUndefined();
}
JSValue JSWebGLRenderingContextBase::getShaderParameter(ExecState& state)
{
if (state.argumentCount() != 2)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
ExceptionCode ec = 0;
WebGLRenderingContextBase& context = wrapped();
if (!state.uncheckedArgument(0).isUndefinedOrNull() && !state.uncheckedArgument(0).inherits(JSWebGLShader::info()))
return throwTypeError(&state);
WebGLShader* shader = JSWebGLShader::toWrapped(state.uncheckedArgument(0));
unsigned pname = state.uncheckedArgument(1).toInt32(&state);
if (state.hadException())
return jsUndefined();
WebGLGetInfo info = context.getShaderParameter(shader, pname, ec);
if (ec) {
setDOMException(&state, ec);
return jsUndefined();
}
return toJS(&state, globalObject(), info);
}
JSValue JSWebGLRenderingContextBase::getUniform(ExecState& state)
{
if (state.argumentCount() != 2)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
ExceptionCode ec = 0;
WebGLRenderingContextBase& context = wrapped();
WebGLProgram* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
return throwTypeError(&state);
WebGLUniformLocation* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(1));
if (!location && !state.uncheckedArgument(1).isUndefinedOrNull())
return throwTypeError(&state);
WebGLGetInfo info = context.getUniform(program, location, ec);
if (ec) {
setDOMException(&state, ec);
return jsUndefined();
}
return toJS(&state, globalObject(), info);
}
JSValue JSWebGLRenderingContextBase::getExtension(ExecState& state)
{
if (state.argumentCount() < 1)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
WebGLRenderingContextBase& context = wrapped();
const String name = state.uncheckedArgument(0).toString(&state)->value(&state);
if (state.hadException())
return jsUndefined();
WebGLExtension* extension = context.getExtension(name);
return toJS(&state, globalObject(), extension);
}
JSValue JSDocument::createTouchList(ExecState& state)
{
auto touchList = TouchList::create();
for (size_t i = 0; i < state.argumentCount(); ++i) {
auto* item = JSTouch::toWrapped(state.uncheckedArgument(i));
if (!item)
return JSValue::decode(throwArgumentTypeError(state, i, "touches", "Document", "createTouchList", "Touch"));
touchList->append(*item);
}
return toJSNewlyCreated(&state, globalObject(), WTFMove(touchList));
}
JSValue JSWebGLRenderingContextBase::getAttachedShaders(ExecState& state)
{
if (state.argumentCount() < 1)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
ExceptionCode ec = 0;
WebGLRenderingContextBase& context = wrapped();
WebGLProgram* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
return throwTypeError(&state);
Vector<RefPtr<WebGLShader>> shaders;
bool succeed = context.getAttachedShaders(program, shaders, ec);
if (ec) {
setDOMException(&state, ec);
return jsNull();
}
if (!succeed)
return jsNull();
JSC::MarkedArgumentBuffer list;
for (size_t ii = 0; ii < shaders.size(); ++ii)
list.append(toJS(&state, globalObject(), shaders[ii].get()));
return constructArray(&state, 0, globalObject(), list);
}
JSValue JSHTMLAllCollection::item(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (UNLIKELY(state.argumentCount() < 1))
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
String argument = state.uncheckedArgument(0).toWTFString(&state);
if (Optional<uint32_t> index = parseIndex(*argument.impl()))
return toJS(&state, globalObject(), wrapped().item(index.value()));
return namedItems(state, this, Identifier::fromString(&state, argument));
}
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();
}
static JSValue getObjectParameter(JSWebGLRenderingContextBase* obj, ExecState& state, ObjectType objectType)
{
if (state.argumentCount() != 2)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
ExceptionCode ec = 0;
WebGLRenderingContextBase& context = obj->wrapped();
unsigned target = state.uncheckedArgument(0).toInt32(&state);
if (state.hadException())
return jsUndefined();
unsigned pname = state.uncheckedArgument(1).toInt32(&state);
if (state.hadException())
return jsUndefined();
WebGLGetInfo info;
switch (objectType) {
case kBuffer:
info = context.getBufferParameter(target, pname, ec);
break;
case kRenderbuffer:
info = context.getRenderbufferParameter(target, pname, ec);
break;
case kTexture:
info = context.getTexParameter(target, pname, ec);
break;
case kVertexAttrib:
// target => index
info = context.getVertexAttrib(target, pname, ec);
break;
default:
notImplemented();
break;
}
if (ec) {
setDOMException(&state, ec);
return jsUndefined();
}
return toJS(&state, obj->globalObject(), info);
}
JSValue JSWebGLRenderingContextBase::getFramebufferAttachmentParameter(ExecState& state)
{
if (state.argumentCount() != 3)
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
ExceptionCode ec = 0;
WebGLRenderingContextBase& context = wrapped();
unsigned target = state.uncheckedArgument(0).toInt32(&state);
if (state.hadException())
return jsUndefined();
unsigned attachment = state.uncheckedArgument(1).toInt32(&state);
if (state.hadException())
return jsUndefined();
unsigned pname = state.uncheckedArgument(2).toInt32(&state);
if (state.hadException())
return jsUndefined();
WebGLGetInfo info = context.getFramebufferAttachmentParameter(target, attachment, pname, ec);
if (ec) {
setDOMException(&state, ec);
return jsUndefined();
}
return toJS(&state, globalObject(), info);
}
JSValue JSNode::replaceChild(ExecState& state)
{
if (UNLIKELY(state.argumentCount() < 2))
return state.vm().throwException(&state, createNotEnoughArgumentsError(&state));
auto* newChild = JSNode::toWrapped(state.uncheckedArgument(0));
JSValue oldChildValue = state.uncheckedArgument(1);
auto* oldChild = JSNode::toWrapped(oldChildValue);
if (UNLIKELY(!newChild || !oldChild)) {
if (!newChild)
return JSValue::decode(throwArgumentTypeError(state, 0, "node", "Node", "replaceChild", "Node"));
return JSValue::decode(throwArgumentTypeError(state, 1, "child", "Node", "replaceChild", "Node"));
}
ExceptionCode ec = 0;
if (UNLIKELY(!wrapped().replaceChild(*newChild, *oldChild, ec))) {
setDOMException(&state, ec);
return jsUndefined();
}
ASSERT(!ec);
return oldChildValue;
}
