ExceptionOr<Ref<WebKitCSSMatrix>> WebKitCSSMatrix::create(const String& string)
{
auto result = adoptRef(*new WebKitCSSMatrix);
auto setMatrixValueResult = result->setMatrixValue(string);
if (setMatrixValueResult.hasException())
return setMatrixValueResult.releaseException();
return WTFMove(result);
}
jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region)
{
SkASSERT(region != NULL);
jobject obj = env->NewObject(gRegion_class, gRegion_constructorMethodID,
static_cast<jint>(reinterpret_cast<uintptr_t>(region)), 0);
hasException(env); // For the side effect of logging.
return obj;
}
ExceptionOr<RefPtr<ArrayBuffer>> FileReaderSync::readAsArrayBuffer(ScriptExecutionContext& scriptExecutionContext, Blob& blob)
{
FileReaderLoader loader(FileReaderLoader::ReadAsArrayBuffer, 0);
auto result = startLoading(scriptExecutionContext, loader, blob);
if (result.hasException())
return result.releaseException();
return loader.arrayBufferResult();
}
ExceptionOr<Ref<IDBRequest>> IDBIndex::openKeyCursor(ExecState& execState, JSValue key, const String& direction)
{
LOG(IndexedDB, "IDBIndex::openKeyCursor");
auto keyRange = IDBKeyRange::only(execState, key);
if (keyRange.hasException())
return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The parameter is not a valid key.") };
return openKeyCursor(execState, keyRange.releaseReturnValue().ptr(), direction);
}
ExceptionOr<void> ShadowRoot::setInnerHTML(const String& markup)
{
if (isOrphan())
return Exception { INVALID_ACCESS_ERR };
auto fragment = createFragmentForInnerOuterHTML(*host(), markup, AllowScriptingContent);
if (fragment.hasException())
return fragment.releaseException();
return replaceChildrenWithFragment(*this, fragment.releaseReturnValue());
}
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;
}
ExceptionOr<void> Worker::postMessage(RefPtr<SerializedScriptValue>&& message, Vector<RefPtr<MessagePort>>&& ports)
{
// Disentangle the port in preparation for sending it to the remote context.
auto channels = MessagePort::disentanglePorts(WTFMove(ports));
if (channels.hasException())
return channels.releaseException();
m_contextProxy->postMessageToWorkerGlobalScope(WTFMove(message), channels.releaseReturnValue());
return { };
}
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;
}
jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap)
{
SkASSERT(bitmap != NULL);
jobject obj = env->NewObject(gBitmapRegionDecoder_class,
gBitmapRegionDecoder_constructorMethodID,
static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)));
hasException(env); // For the side effect of logging.
return obj;
}
ExceptionOr<void> SVGLengthValue::convertToSpecifiedUnits(unsigned short type, const SVGLengthContext& context)
{
if (type == LengthTypeUnknown || type > LengthTypePC)
return Exception { NOT_SUPPORTED_ERR };
auto valueInUserUnits = valueForBindings(context);
if (valueInUserUnits.hasException())
return valueInUserUnits.releaseException();
auto originalUnitAndType = m_unit;
m_unit = storeUnit(extractMode(m_unit), static_cast<SVGLengthType>(type));
auto result = setValue(valueInUserUnits.releaseReturnValue(), context);
if (result.hasException()) {
m_unit = originalUnitAndType;
return result.releaseException();
}
return { };
}
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;
}
QDate YearlyRecurrence::prevOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date > endDate()) return lastOccurrence();
}
QDate prevdate = date;
if(!include_equals) prevdate = calSys->addDays(prevdate, -1);
if(prevdate < startDate()) return QDate();
if(prevdate == startDate()) return startDate();
if(i_frequency != 1) {
int i = (calSys->year(prevdate) - calSys->year(startDate())) % i_frequency;
if(i != 0) {
prevdate = calSys->addYears(prevdate, - i);
}
}
if(calSys->year(prevdate) == calSys->year(startDate())) return startDate();
if(i_dayofyear > 0) {
if(calSys->dayOfYear(prevdate) < i_dayofyear) {
prevdate = calSys->addYears(prevdate, -i_frequency);
if(calSys->year(prevdate) == calSys->year(startDate())) return startDate();
}
if(i_dayofyear > calSys->daysInYear(prevdate)) {
do {
prevdate = calSys->addYears(prevdate, -i_frequency);
if(calSys->year(prevdate) <= calSys->year(startDate())) return startDate();
} while(i_dayofyear > calSys->daysInYear(prevdate));
}
prevdate = calSys->addDays(prevdate, i_dayofyear - calSys->dayOfYear(prevdate));
} else {
int day = i_dayofmonth;
if(i_dayofweek > 0) day = get_day_in_month(calSys->year(prevdate), i_month, i_week, i_dayofweek);
if(day <= 0 || calSys->month(prevdate) < i_month || (calSys->month(prevdate) == i_month && calSys->day(prevdate) < day)) {
do {
prevdate = calSys->addYears(prevdate, -i_frequency);
if(i_dayofweek > 0) day = get_day_in_month(calSys->year(prevdate), i_month, i_week, i_dayofweek);
if(calSys->year(prevdate) == calSys->year(startDate())) return startDate();
} while(day <= 0);
}
if(i_dayofweek <= 0) {
calSys->setYMD(prevdate, calSys->year(prevdate), i_month, 1);
if(day > calSys->daysInMonth(prevdate)) {
do {
prevdate = calSys->addYears(prevdate, -i_frequency);
calSys->setYMD(prevdate, calSys->year(prevdate), i_month, 1);
if(calSys->year(prevdate) <= calSys->year(startDate())) return startDate();
} while(day > calSys->daysInMonth(prevdate));
}
}
calSys->setYMD(prevdate, calSys->year(prevdate), i_month, day);
}
if(prevdate < startDate()) return QDate();
if(hasException(prevdate)) return prevOccurrence(prevdate);
return prevdate;
}
ExceptionOr<void> CryptoAlgorithmRSA_OAEP::platformDecrypt(const CryptoAlgorithmRsaOaepParamsDeprecated& parameters, const CryptoKeyRSA& key, const CryptoOperationData& data, VectorCallback&& callback, VoidCallback&& failureCallback)
{
ASSERT(parameters.hasLabel || parameters.label.isEmpty());
auto result = decryptRSA_OAEP(parameters.hash, parameters.label, key.platformKey(), key.keySizeInBits(), data.first, data.second);
if (result.hasException()) {
failureCallback();
return { };
}
callback(result.releaseReturnValue());
return { };
}
bool KateScript::load()
{
if(m_loaded)
return m_loadSuccessful;
m_loaded = true;
m_loadSuccessful = false; // here set to false, and at end of function to true
// read the script file into memory
QString source;
if (m_inputType == InputURL) {
if (!Kate::Script::readFile(m_url, source)) {
return false;
}
} else source = m_script;
// create script engine, register meta types
m_engine = new QScriptEngine();
qScriptRegisterMetaType (m_engine, cursorToScriptValue, cursorFromScriptValue);
qScriptRegisterMetaType (m_engine, rangeToScriptValue, rangeFromScriptValue);
// export read & require function and add the require guard object
m_engine->globalObject().setProperty("read", m_engine->newFunction(Kate::Script::read));
m_engine->globalObject().setProperty("require", m_engine->newFunction(Kate::Script::require));
m_engine->globalObject().setProperty("require_guard", m_engine->newObject());
// export debug function
m_engine->globalObject().setProperty("debug", m_engine->newFunction(Kate::Script::debug));
// export translation functions
m_engine->globalObject().setProperty("i18n", m_engine->newFunction(Kate::Script::i18n));
m_engine->globalObject().setProperty("i18nc", m_engine->newFunction(Kate::Script::i18nc));
m_engine->globalObject().setProperty("i18ncp", m_engine->newFunction(Kate::Script::i18ncp));
m_engine->globalObject().setProperty("i18np", m_engine->newFunction(Kate::Script::i18np));
// register scripts itself
QScriptValue result = m_engine->evaluate(source, m_url);
if (hasException(result, m_url))
return false;
// AFTER SCRIPT: set the view/document objects as necessary
m_engine->globalObject().setProperty("document", m_engine->newQObject(m_document = new KateScriptDocument()));
m_engine->globalObject().setProperty("view", m_engine->newQObject(m_view = new KateScriptView()));
// yip yip!
m_loadSuccessful = true;
// load i18n catalog if available
if (!generalHeader().catalog().isEmpty()) {
kDebug() << "loading i18n catalog" << generalHeader().catalog();
KGlobal::locale()->insertCatalog(generalHeader().catalog());
}
return true;
}
static RefPtr<Range> makeSearchRange(const Position& position)
{
auto* node = position.deprecatedNode();
if (!node)
return nullptr;
auto* boundary = deprecatedEnclosingBlockFlowElement(node);
if (!boundary)
return nullptr;
auto searchRange = Range::create(node->document());
auto result = searchRange->selectNodeContents(*boundary);
if (result.hasException())
return nullptr;
Position start { position.parentAnchoredEquivalent() };
result = searchRange->setStart(*start.containerNode(), start.offsetInContainerNode());
if (result.hasException())
return nullptr;
return WTFMove(searchRange);
}
ExceptionOr<void> PaymentHandler::canCreateSession(Document& document)
{
#if ENABLE(APPLE_PAY)
auto result = PaymentSession::canCreateSession(document);
if (result.hasException())
return Exception { SecurityError, result.releaseException().releaseMessage() };
#else
UNUSED_PARAM(document);
#endif
return { };
}
void ExceptionStore::throwPossibleException()
{
/* On win32-g++, with GCC 3.4.2 std::uncaught_exception() isn't reliable. */
if (hasException()
#ifndef Q_CC_MINGW
&& std::uncaught_exception() == false
#endif
) {
exceptionHolder.base->hasThrown = true;
exceptionHolder.exception()->raise();
}
}
jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region)
{
SkASSERT(region != NULL);
jobject obj = env->AllocObject(gRegion_class);
if (obj) {
env->CallVoidMethod(obj, gRegion_constructorMethodID, (jint)region, 0);
if (hasException(env)) {
obj = NULL;
}
}
return obj;
}
ExceptionOr<void> SVGLengthValue::setValue(float value, const SVGLengthContext& context)
{
// 100% = 100.0 instead of 1.0 for historical reasons, this could eventually be changed
if (extractType(m_unit) == LengthTypePercentage)
value = value / 100;
auto convertedValue = context.convertValueFromUserUnits(value, extractMode(m_unit), extractType(m_unit));
if (convertedValue.hasException())
return convertedValue.releaseException();
m_valueInSpecifiedUnits = convertedValue.releaseReturnValue();
return { };
}
jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer,
bool isMutable, jbyteArray ninepatch, int density)
{
SkASSERT(bitmap);
SkASSERT(bitmap->pixelRef());
jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID,
static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)),
buffer, isMutable, ninepatch, density);
hasException(env); // For the side effect of logging.
return obj;
}
ExceptionOr<RefPtr<RTCConfiguration>> RTCConfiguration::create(const Dictionary& configuration)
{
if (configuration.isUndefinedOrNull())
return nullptr;
auto result = adoptRef(*new RTCConfiguration);
auto initializeResult = result->initialize(configuration);
if (initializeResult.hasException())
return initializeResult.releaseException();
return RefPtr<RTCConfiguration> { WTFMove(result) };
}
ExceptionOr<void> RTCConfiguration::initialize(const Dictionary& configuration)
{
ArrayValue iceServers;
bool ok = configuration.get("iceServers", iceServers);
if (!ok || iceServers.isUndefinedOrNull())
return Exception { TYPE_MISMATCH_ERR };
size_t numberOfServers;
ok = iceServers.length(numberOfServers);
if (!ok)
return Exception { TYPE_MISMATCH_ERR };
if (!numberOfServers)
return Exception { INVALID_ACCESS_ERR };
for (size_t i = 0; i < numberOfServers; ++i) {
Dictionary iceServerDict;
ok = iceServers.get(i, iceServerDict);
if (!ok)
return Exception { TYPE_MISMATCH_ERR };
auto server = parseIceServer(iceServerDict);
if (server.hasException())
return server.releaseException();
m_iceServers.append(server.releaseReturnValue());
}
String iceTransportPolicy;
if (configuration.get("iceTransportPolicy", iceTransportPolicy)) {
if (iceTransportPolicy == "relay")
m_iceTransportPolicy = IceTransportPolicy::Relay;
else if (iceTransportPolicy == "all")
m_iceTransportPolicy = IceTransportPolicy::All;
else
return Exception { TypeError };
}
String bundlePolicy;
if (configuration.get("bundlePolicy", bundlePolicy)) {
if (bundlePolicy == "balanced")
m_bundlePolicy = BundlePolicy::Balanced;
else if (bundlePolicy == "max-compat")
m_bundlePolicy = BundlePolicy::MaxCompat;
else if (bundlePolicy == "max-bundle")
m_bundlePolicy = BundlePolicy::MaxBundle;
else
return Exception { TypeError };
}
return { };
}
void DOMFileSystem::getFile(ScriptExecutionContext& context, FileSystemFileEntry& fileEntry, GetFileCallback&& completionCallback)
{
auto virtualPath = fileEntry.virtualPath();
auto fullPath = evaluatePath(virtualPath);
m_workQueue->dispatch([context = makeRef(context), fullPath = crossThreadCopy(fullPath), virtualPath = crossThreadCopy(virtualPath), completionCallback = WTFMove(completionCallback)]() mutable {
auto validatedVirtualPath = validatePathIsExpectedType(fullPath, WTFMove(virtualPath), FileMetadata::Type::File);
callOnMainThread([context = WTFMove(context), fullPath = crossThreadCopy(fullPath), validatedVirtualPath = crossThreadCopy(validatedVirtualPath), completionCallback = WTFMove(completionCallback)]() mutable {
if (validatedVirtualPath.hasException())
completionCallback(validatedVirtualPath.releaseException());
else
completionCallback(File::create(fullPath));
});
});
}
void JSStorage::getOwnPropertyNames(JSObject* object, ExecState* state, PropertyNameArray& propertyNames, EnumerationMode mode)
{
VM& vm = state->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto& thisObject = *jsCast<JSStorage*>(object);
auto lengthResult = thisObject.wrapped().length();
if (lengthResult.hasException()) {
propagateException(*state, scope, lengthResult.releaseException());
return;
}
unsigned length = lengthResult.releaseReturnValue();
for (unsigned i = 0; i < length; ++i) {
auto keyResult = thisObject.wrapped().key(i);
if (keyResult.hasException()) {
propagateException(*state, scope, lengthResult.releaseException());
return;
}
propertyNames.add(Identifier::fromString(state, keyResult.releaseReturnValue()));
}
Base::getOwnPropertyNames(&thisObject, state, propertyNames, mode);
}
static gboolean webkit_dom_html_embed_element_dispatch_event(WebKitDOMEventTarget* target, WebKitDOMEvent* event, GError** error)
{
WebCore::Event* coreEvent = WebKit::core(event);
if (!coreEvent)
return false;
WebCore::HTMLEmbedElement* coreTarget = static_cast<WebCore::HTMLEmbedElement*>(WEBKIT_DOM_OBJECT(target)->coreObject);
auto result = coreTarget->dispatchEventForBindings(*coreEvent);
if (result.hasException()) {
WebCore::ExceptionCodeDescription description(result.releaseException().code());
g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), description.code, description.name);
return false;
}
return result.releaseReturnValue();
}
jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer,
int bitmapCreateFlags, jbyteArray ninepatch, jintArray layoutbounds, int density)
{
SkASSERT(bitmap);
SkASSERT(bitmap->pixelRef());
bool isMutable = bitmapCreateFlags & kBitmapCreateFlag_Mutable;
bool isPremultiplied = bitmapCreateFlags & kBitmapCreateFlag_Premultiplied;
jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID,
static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)), buffer,
bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied,
ninepatch, layoutbounds);
hasException(env); // For the side effect of logging.
return obj;
}
void Recurrence::addException(const QDate &date) {
if(hasException(date) || !date.isValid()) return;
if(date == d_startdate) {
d_startdate = nextOccurrence(d_startdate);
if(d_startdate.isNull()) d_enddate = QDate();
return;
}
if(date == d_enddate) {
d_enddate = prevOccurrence(d_enddate);
if(d_enddate.isNull()) d_startdate = QDate();
return;
}
exceptions.append(date);
qSort(exceptions);
}
jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable,
jbyteArray ninepatch, int density)
{
SkASSERT(bitmap != NULL);
SkASSERT(NULL != bitmap->pixelRef());
jobject obj = env->AllocObject(gBitmap_class);
if (obj) {
env->CallVoidMethod(obj, gBitmap_constructorMethodID,
(jint)bitmap, isMutable, ninepatch, density);
if (hasException(env)) {
obj = NULL;
}
}
return obj;
}
ExceptionOr<int> CSSStyleSheet::addRule(const String& selector, const String& style, std::optional<unsigned> index)
{
StringBuilder text;
text.append(selector);
text.appendLiteral(" { ");
text.append(style);
if (!style.isEmpty())
text.append(' ');
text.append('}');
auto insertRuleResult = insertRule(text.toString(), index.value_or(length()));
if (insertRuleResult.hasException())
return insertRuleResult.releaseException();
// As per Microsoft documentation, always return -1.
return -1;
}
bool JSTestNamedDeleterThrowingException::deleteProperty(JSCell* cell, ExecState* state, PropertyName propertyName)
{
auto& thisObject = *jsCast<JSTestNamedDeleterThrowingException*>(cell);
auto& impl = thisObject.wrapped();
if (isVisibleNamedProperty<OverrideBuiltins::No>(*state, thisObject, propertyName)) {
auto result = impl.deleteNamedProperty(propertyNameToString(propertyName));
if (result.hasException()) {
auto throwScope = DECLARE_THROW_SCOPE(state->vm());
propagateException(*state, throwScope, result.releaseException());
return true;
}
return result.releaseReturnValue();
}
return JSObject::deleteProperty(cell, state, propertyName);
}
