RefPtr<Text> Text::replaceWholeText(const String& newText, ExceptionCode&)
{
// Remove all adjacent text nodes, and replace the contents of this one.
// Protect startText and endText against mutation event handlers removing the last ref
RefPtr<Text> startText = const_cast<Text*>(earliestLogicallyAdjacentTextNode(this));
RefPtr<Text> endText = const_cast<Text*>(latestLogicallyAdjacentTextNode(this));
RefPtr<Text> protectedThis(this); // Mutation event handlers could cause our last ref to go away
RefPtr<ContainerNode> parent = parentNode(); // Protect against mutation handlers moving this node during traversal
for (RefPtr<Node> n = startText; n && n != this && n->isTextNode() && n->parentNode() == parent;) {
Ref<Node> nodeToRemove(n.releaseNonNull());
n = nodeToRemove->nextSibling();
parent->removeChild(WTF::move(nodeToRemove), IGNORE_EXCEPTION);
}
if (this != endText) {
Node* onePastEndText = endText->nextSibling();
for (RefPtr<Node> n = nextSibling(); n && n != onePastEndText && n->isTextNode() && n->parentNode() == parent;) {
Ref<Node> nodeToRemove(n.releaseNonNull());
n = nodeToRemove->nextSibling();
parent->removeChild(WTF::move(nodeToRemove), IGNORE_EXCEPTION);
}
}
if (newText.isEmpty()) {
if (parent && parentNode() == parent)
parent->removeChild(*this, IGNORE_EXCEPTION);
return nullptr;
}
setData(newText, IGNORE_EXCEPTION);
return protectedThis;
}
RefPtr<CSSValueList> CSSParser::parsePaintOrder()
{
CSSParserValue* value = m_valueList->current();
Vector<CSSValueID> paintTypeList;
RefPtr<CSSPrimitiveValue> fill;
RefPtr<CSSPrimitiveValue> stroke;
RefPtr<CSSPrimitiveValue> markers;
while (value) {
if (value->id == CSSValueFill && !fill)
fill = CSSPrimitiveValue::createIdentifier(value->id);
else if (value->id == CSSValueStroke && !stroke)
stroke = CSSPrimitiveValue::createIdentifier(value->id);
else if (value->id == CSSValueMarkers && !markers)
markers = CSSPrimitiveValue::createIdentifier(value->id);
else
return nullptr;
paintTypeList.append(value->id);
value = m_valueList->next();
}
// After parsing we serialize the paint-order list. Since it is not possible to
// pop a last list items from CSSValueList without bigger cost, we create the
// list after parsing.
CSSValueID firstPaintOrderType = paintTypeList.at(0);
auto paintOrderList = CSSValueList::createSpaceSeparated();
switch (firstPaintOrderType) {
case CSSValueFill:
FALLTHROUGH;
case CSSValueStroke:
paintOrderList->append(firstPaintOrderType == CSSValueFill ? fill.releaseNonNull() : stroke.releaseNonNull());
if (paintTypeList.size() > 1) {
if (paintTypeList.at(1) == CSSValueMarkers)
paintOrderList->append(markers.releaseNonNull());
}
break;
case CSSValueMarkers:
paintOrderList->append(markers.releaseNonNull());
if (paintTypeList.size() > 1) {
if (paintTypeList.at(1) == CSSValueStroke)
paintOrderList->append(stroke.releaseNonNull());
}
break;
default:
ASSERT_NOT_REACHED();
}
return WTFMove(paintOrderList);
}
ExceptionOr<Ref<Database>> DatabaseManager::openDatabase(ScriptExecutionContext& context, const String& name, const String& expectedVersion, const String& displayName, unsigned estimatedSize, RefPtr<DatabaseCallback>&& creationCallback)
{
ScriptController::initializeThreading();
bool setVersionInNewDatabase = !creationCallback;
auto openResult = openDatabaseBackend(context, name, expectedVersion, displayName, estimatedSize, setVersionInNewDatabase);
if (openResult.hasException())
return openResult.releaseException();
RefPtr<Database> database = openResult.releaseReturnValue();
auto databaseContext = this->databaseContext(context);
databaseContext->setHasOpenDatabases();
InspectorInstrumentation::didOpenDatabase(&context, database.copyRef(), context.securityOrigin()->host(), name, expectedVersion);
if (database->isNew() && creationCallback.get()) {
LOG(StorageAPI, "Scheduling DatabaseCreationCallbackTask for database %p\n", database.get());
database->setHasPendingCreationEvent(true);
database->m_scriptExecutionContext->postTask([creationCallback, database] (ScriptExecutionContext&) {
creationCallback->handleEvent(database.get());
database->setHasPendingCreationEvent(false);
});
}
return database.releaseNonNull();
}
ExceptionOr<unsigned> CSSGroupingRule::insertRule(const String& ruleString, unsigned index)
{
ASSERT(m_childRuleCSSOMWrappers.size() == m_groupRule->childRules().size());
if (index > m_groupRule->childRules().size()) {
// INDEX_SIZE_ERR: Raised if the specified index is not a valid insertion point.
return Exception { INDEX_SIZE_ERR };
}
CSSParser parser(parserContext());
CSSStyleSheet* styleSheet = parentStyleSheet();
RefPtr<StyleRuleBase> newRule = parser.parseRule(styleSheet ? &styleSheet->contents() : nullptr, ruleString);
if (!newRule) {
// SYNTAX_ERR: Raised if the specified rule has a syntax error and is unparsable.
return Exception { SYNTAX_ERR };
}
if (newRule->isImportRule()) {
// FIXME: an HIERARCHY_REQUEST_ERR should also be thrown for a @charset or a nested
// @media rule. They are currently not getting parsed, resulting in a SYNTAX_ERR
// to get raised above.
// HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified
// index, e.g., if an @import rule is inserted after a standard rule set or other
// at-rule.
return Exception { HIERARCHY_REQUEST_ERR };
}
CSSStyleSheet::RuleMutationScope mutationScope(this);
m_groupRule->wrapperInsertRule(index, newRule.releaseNonNull());
m_childRuleCSSOMWrappers.insert(index, RefPtr<CSSRule>());
return index;
}
bool CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle, Ref<RenderStyle>& blendedStyle)
{
// We don't do any transitions if we don't have a currentStyle (on startup).
updateTransitions(&renderer, currentStyle, &targetStyle);
updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
m_keyframeAnimations.checkConsistency();
RefPtr<RenderStyle> animatedStyle;
bool animationStateChanged = false;
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (auto& transition : m_transitions.values()) {
if (transition->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
animationStateChanged = true;
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (auto& name : m_keyframeAnimationOrderMap) {
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
if (keyframeAnim && keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
animationStateChanged = true;
}
if (animatedStyle)
blendedStyle = animatedStyle.releaseNonNull();
else
blendedStyle = targetStyle;
return animationStateChanged;
}
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;
}
PassRef<RenderStyle> CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
{
RefPtr<RenderStyle> resultStyle;
// We don't do any transitions if we don't have a currentStyle (on startup).
updateTransitions(&renderer, currentStyle, &targetStyle);
updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
m_keyframeAnimations.checkConsistency();
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
if (!m_transitions.isEmpty()) {
CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) {
if (ImplicitAnimation* anim = it->value.get())
anim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
}
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (Vector<AtomicStringImpl*>::const_iterator it = m_keyframeAnimationOrderMap.begin(); it != m_keyframeAnimationOrderMap.end(); ++it) {
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(*it);
if (keyframeAnim)
keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
}
return resultStyle ? resultStyle.releaseNonNull() : targetStyle;
}
RefPtr<FetchRequest> FetchRequest::create(ScriptExecutionContext& context, FetchRequest& input, const Dictionary& init, ExceptionCode& ec)
{
if (input.isDisturbed()) {
ec = TypeError;
return nullptr;
}
FetchRequest::InternalRequest internalRequest(input.m_internalRequest);
if (!buildOptions(internalRequest, context, init)) {
ec = TypeError;
return nullptr;
}
RefPtr<FetchHeaders> headers = buildHeaders(init, internalRequest, input.m_headers.ptr());
if (!headers) {
ec = TypeError;
return nullptr;
}
FetchBody body = buildBody(init, *headers, &input.m_body);
if (!validateBodyAndMethod(body, internalRequest)) {
ec = TypeError;
return nullptr;
}
if (!input.m_body.isEmpty())
input.setDisturbed();
return adoptRef(*new FetchRequest(context, WTFMove(body), headers.releaseNonNull(), WTFMove(internalRequest)));
}
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;
}
RefPtr<Document> DOMImplementation::createDocument(const String& namespaceURI,
const String& qualifiedName, DocumentType* doctype, ExceptionCode& ec)
{
RefPtr<Document> doc;
if (namespaceURI == SVGNames::svgNamespaceURI)
doc = SVGDocument::create(0, URL());
else if (namespaceURI == HTMLNames::xhtmlNamespaceURI)
doc = Document::createXHTML(0, URL());
else
doc = Document::create(0, URL());
doc->setSecurityOriginPolicy(m_document.securityOriginPolicy());
RefPtr<Node> documentElement;
if (!qualifiedName.isEmpty()) {
documentElement = doc->createElementNS(namespaceURI, qualifiedName, ec);
if (ec)
return 0;
}
if (doctype)
doc->appendChild(*doctype);
if (documentElement)
doc->appendChild(documentElement.releaseNonNull());
return doc;
}
RefPtr<FetchRequest> FetchRequest::create(ScriptExecutionContext& context, const String& url, const Dictionary& init, ExceptionCode& ec)
{
// FIXME: Tighten the URL parsing algorithm according https://url.spec.whatwg.org/#concept-url-parser.
URL requestURL = context.completeURL(url);
if (!requestURL.isValid() || !requestURL.user().isEmpty() || !requestURL.pass().isEmpty()) {
ec = TypeError;
return nullptr;
}
FetchRequest::InternalRequest internalRequest;
internalRequest.options.setMode(FetchOptions::Mode::Cors);
internalRequest.options.setCredentials(FetchOptions::Credentials::Omit);
internalRequest.referrer = ASCIILiteral("client");
internalRequest.request.setURL(requestURL);
if (!buildOptions(internalRequest, context, init)) {
ec = TypeError;
return nullptr;
}
RefPtr<FetchHeaders> headers = buildHeaders(init, internalRequest);
if (!headers) {
ec = TypeError;
return nullptr;
}
FetchBody body = buildBody(init, *headers);
if (!validateBodyAndMethod(body, internalRequest)) {
ec = TypeError;
return nullptr;
}
return adoptRef(*new FetchRequest(context, WTFMove(body), headers.releaseNonNull(), WTFMove(internalRequest)));
}
void FindIndicator::draw(GraphicsContext& graphicsContext, const IntRect& /*dirtyRect*/)
{
#if ENABLE(LEGACY_FIND_INDICATOR_STYLE)
for (size_t i = 0; i < m_textRectsInSelectionRectCoordinates.size(); ++i) {
FloatRect textRect = m_textRectsInSelectionRectCoordinates[i];
textRect.move(leftBorderThickness, topBorderThickness);
FloatRect outerPathRect = inflateRect(textRect, horizontalOutsetToCenterOfLightBorder, verticalOutsetToCenterOfLightBorder);
FloatRect innerPathRect = inflateRect(textRect, horizontalPaddingInsideLightBorder, verticalPaddingInsideLightBorder);
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.setShadow(FloatSize(shadowOffsetX, shadowOffsetY), shadowBlurRadius, shadowColor(), ColorSpaceSRGB);
graphicsContext.setFillColor(lightBorderColor(), ColorSpaceDeviceRGB);
graphicsContext.fillPath(pathWithRoundedRect(outerPathRect, cornerRadius));
}
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.clip(pathWithRoundedRect(innerPathRect, cornerRadius));
RefPtr<Gradient> gradient = Gradient::create(FloatPoint(innerPathRect.x(), innerPathRect.y()), FloatPoint(innerPathRect.x(), innerPathRect.maxY()));
gradient->addColorStop(0, gradientLightColor());
gradient->addColorStop(1, gradientDarkColor());
graphicsContext.setFillGradient(gradient.releaseNonNull());
graphicsContext.fillRect(outerPathRect);
}
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.translate(FloatSize(roundf(leftBorderThickness), roundf(topBorderThickness)));
IntRect contentImageRect = enclosingIntRect(m_textRectsInSelectionRectCoordinates[i]);
m_contentImage->paint(graphicsContext, m_contentImageScaleFactor, contentImageRect.location(), contentImageRect);
}
}
#else
for (auto& textRect : m_textRectsInSelectionRectCoordinates) {
FloatRect blurRect = textRect;
blurRect.move(flatShadowBlurRadius + flatStyleHorizontalBorder, flatShadowBlurRadius + flatStyleVerticalBorder);
FloatRect outerPathRect = inflateRect(blurRect, flatStyleHorizontalBorder, flatStyleVerticalBorder);
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.setShadow(FloatSize(), flatRimShadowBlurRadius, flatRimShadowColor(), ColorSpaceSRGB);
graphicsContext.setFillColor(flatHighlightColor(), ColorSpaceSRGB);
graphicsContext.fillRect(outerPathRect);
graphicsContext.setShadow(FloatSize(flatShadowOffsetX, flatShadowOffsetY), flatShadowBlurRadius, flatDropShadowColor(), ColorSpaceSRGB);
graphicsContext.fillRect(outerPathRect);
}
{
GraphicsContextStateSaver stateSaver(graphicsContext);
graphicsContext.translate(FloatSize(flatShadowBlurRadius + flatStyleHorizontalBorder, flatShadowBlurRadius + flatStyleVerticalBorder));
IntRect contentImageRect = enclosingIntRect(textRect);
m_contentImage->paint(graphicsContext, m_contentImageScaleFactor, contentImageRect.location(), contentImageRect);
}
}
#endif
}
Ref<RenderStyle> CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
{
RefPtr<RenderStyle> resultStyle;
// We don't do any transitions if we don't have a currentStyle (on startup).
updateTransitions(&renderer, currentStyle, &targetStyle);
updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
m_keyframeAnimations.checkConsistency();
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
if (!m_transitions.isEmpty()) {
for (auto& transition : m_transitions.values())
transition->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (auto& name : m_keyframeAnimationOrderMap) {
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
if (keyframeAnim)
keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
}
if (resultStyle)
return resultStyle.releaseNonNull();
return targetStyle;
}
TEST(CalculationValue, LengthConstructionReleasedValue)
{
RefPtr<WebCore::CalculationValue> value = createTestValue();
EXPECT_EQ(1U, value->refCount());
{
auto* rawValue = value.get();
WebCore::Length length(value.releaseNonNull());
EXPECT_EQ(1U, rawValue->refCount());
EXPECT_EQ(0U, deletionCount);
}
EXPECT_EQ(1U, deletionCount);
deletionCount = 0;
value = createTestValue();
{
auto* rawValue = value.get();
WebCore::Length lengthA(value.releaseNonNull());
EXPECT_EQ(1U, rawValue->refCount());
WebCore::Length lengthB(lengthA);
EXPECT_EQ(1U, rawValue->refCount());
EXPECT_EQ(0U, deletionCount);
}
EXPECT_EQ(1U, deletionCount);
deletionCount = 0;
value = createTestValue();
{
auto* rawValue = value.get();
WebCore::Length lengthC(value.releaseNonNull());
EXPECT_EQ(1U, rawValue->refCount());
WebCore::Length lengthD(std::move(lengthC));
EXPECT_EQ(1U, rawValue->refCount());
EXPECT_EQ(0U, deletionCount);
}
EXPECT_EQ(1U, deletionCount);
deletionCount = 0;
}
void RenderTreeUpdater::updateBeforeOrAfterPseudoElement(Element& current, PseudoId pseudoId)
{
PseudoElement* pseudoElement = pseudoId == BEFORE ? current.beforePseudoElement() : current.afterPseudoElement();
if (auto* renderer = pseudoElement ? pseudoElement->renderer() : nullptr)
renderTreePosition().invalidateNextSibling(*renderer);
bool needsPseudoElement = WebCore::needsPseudoElement(current, pseudoId);
if (!needsPseudoElement) {
if (pseudoElement) {
if (pseudoId == BEFORE)
current.clearBeforePseudoElement();
else
current.clearAfterPseudoElement();
}
return;
}
RefPtr<PseudoElement> newPseudoElement;
if (!pseudoElement) {
newPseudoElement = PseudoElement::create(current, pseudoId);
pseudoElement = newPseudoElement.get();
}
auto newStyle = RenderStyle::clonePtr(*current.renderer()->getCachedPseudoStyle(pseudoId, ¤t.renderer()->style()));
auto elementUpdate = Style::TreeResolver::createAnimatedElementUpdate(WTFMove(newStyle), *pseudoElement, Style::NoChange);
if (elementUpdate.change == Style::NoChange)
return;
if (newPseudoElement) {
InspectorInstrumentation::pseudoElementCreated(m_document.page(), *newPseudoElement);
if (pseudoId == BEFORE)
current.setBeforePseudoElement(newPseudoElement.releaseNonNull());
else
current.setAfterPseudoElement(newPseudoElement.releaseNonNull());
}
updateElementRenderer(*pseudoElement, elementUpdate);
if (elementUpdate.change == Style::Detach)
pseudoElement->didAttachRenderers();
else
pseudoElement->didRecalcStyle(elementUpdate.change);
}
void RenderScrollbar::updateScrollbarPart(ScrollbarPart partType, bool destroy)
{
if (partType == NoPart)
return;
RefPtr<RenderStyle> partStyle = destroy ? nullptr : getScrollbarPseudoStyle(partType, pseudoForScrollbarPart(partType));
bool needRenderer = partStyle && partStyle->display() != NONE;
if (needRenderer && partStyle->display() != BLOCK) {
// See if we are a button that should not be visible according to OS settings.
ScrollbarButtonsPlacement buttonsPlacement = theme()->buttonsPlacement();
switch (partType) {
case BackButtonStartPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsSingle || buttonsPlacement == ScrollbarButtonsDoubleStart ||
buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
case ForwardButtonStartPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsDoubleStart || buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
case BackButtonEndPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsDoubleEnd || buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
case ForwardButtonEndPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsSingle || buttonsPlacement == ScrollbarButtonsDoubleEnd ||
buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
default:
break;
}
}
if (needRenderer) {
RenderScrollbarPart*& partRendererSlot = m_parts.add(partType, nullptr).iterator->value;
if (partRendererSlot)
partRendererSlot->setStyle(partStyle.releaseNonNull());
else {
partRendererSlot = new RenderScrollbarPart(owningRenderer()->document(), partStyle.releaseNonNull(), this, partType);
partRendererSlot->initializeStyle();
}
} else {
if (RenderScrollbarPart* partRenderer = m_parts.take(partType))
partRenderer->destroy();
}
}
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;
}
void BackendDispatcher::dispatch(const String& message)
{
Ref<BackendDispatcher> protect(*this);
RefPtr<InspectorValue> parsedMessage;
if (!InspectorValue::parseJSON(message, parsedMessage)) {
reportProtocolError(nullptr, ParseError, ASCIILiteral("Message must be in JSON format"));
return;
}
RefPtr<InspectorObject> messageObject;
if (!parsedMessage->asObject(messageObject)) {
reportProtocolError(nullptr, InvalidRequest, ASCIILiteral("Message must be a JSONified object"));
return;
}
RefPtr<InspectorValue> callIdValue;
if (!messageObject->getValue(ASCIILiteral("id"), callIdValue)) {
reportProtocolError(nullptr, InvalidRequest, ASCIILiteral("'id' property was not found"));
return;
}
long callId = 0;
if (!callIdValue->asInteger(callId)) {
reportProtocolError(nullptr, InvalidRequest, ASCIILiteral("The type of 'id' property must be integer"));
return;
}
RefPtr<InspectorValue> methodValue;
if (!messageObject->getValue(ASCIILiteral("method"), methodValue)) {
reportProtocolError(&callId, InvalidRequest, ASCIILiteral("'method' property wasn't found"));
return;
}
String method;
if (!methodValue->asString(method)) {
reportProtocolError(&callId, InvalidRequest, ASCIILiteral("The type of 'method' property must be string"));
return;
}
size_t position = method.find('.');
if (position == WTF::notFound) {
reportProtocolError(&callId, InvalidRequest, ASCIILiteral("The 'method' property was formatted incorrectly. It should be 'Domain.method'"));
return;
}
String domain = method.substring(0, position);
SupplementalBackendDispatcher* domainDispatcher = m_dispatchers.get(domain);
if (!domainDispatcher) {
reportProtocolError(&callId, MethodNotFound, "'" + domain + "' domain was not found");
return;
}
String domainMethod = method.substring(position + 1);
domainDispatcher->dispatch(callId, domainMethod, messageObject.releaseNonNull());
}
Ref<WebUserContentController> WebUserContentController::getOrCreate(uint64_t identifier)
{
auto& userContentControllerPtr = userContentControllers().add(identifier, nullptr).iterator->value;
if (userContentControllerPtr)
return *userContentControllerPtr;
RefPtr<WebUserContentController> userContentController = adoptRef(new WebUserContentController(identifier));
userContentControllerPtr = userContentController.get();
return userContentController.releaseNonNull();
}
TEST(WTF_RefPtr, ReleaseNonNull)
{
RefLogger a("a");
{
RefPtr<RefLogger> refPtr = &a;
RefPtr<RefLogger> ref = refPtr.releaseNonNull();
}
ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());
}
void Editor::pasteWithPasteboard(Pasteboard* pasteboard, bool allowPlainText, MailBlockquoteHandling mailBlockquoteHandling)
{
RefPtr<Range> range = selectedRange();
if (!range)
return;
bool chosePlainText;
RefPtr<DocumentFragment> fragment = createFragmentFromPasteboardData(*pasteboard, m_frame, *range, allowPlainText, chosePlainText);
if (fragment && shouldInsertFragment(fragment, range, EditorInsertActionPasted))
pasteAsFragment(fragment.releaseNonNull(), canSmartReplaceWithPasteboard(*pasteboard), chosePlainText, mailBlockquoteHandling);
}
CSSValueList::CSSValueList(CSSParserValueList& parserValues)
: CSSValue(ValueListClass)
{
m_valueListSeparator = SpaceSeparator;
m_values.reserveInitialCapacity(parserValues.size());
for (unsigned i = 0, size = parserValues.size(); i < size; ++i) {
RefPtr<CSSValue> value = parserValues.valueAt(i)->createCSSValue();
ASSERT(value);
m_values.uncheckedAppend(value.releaseNonNull());
}
}
JSValue JSWebKitSubtleCrypto::sign(ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (state.argumentCount() < 3)
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
auto algorithm = createAlgorithmFromJSValue(state, state.uncheckedArgument(0));
ASSERT(scope.exception() || algorithm);
if (!algorithm)
return jsUndefined();
auto parameters = JSCryptoAlgorithmDictionary::createParametersForSign(&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(CryptoKeyUsageSign)) {
wrapped().document()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("Key usages do not include 'sign'"));
setDOMException(&state, NOT_SUPPORTED_ERR);
return jsUndefined();
}
CryptoOperationData data;
auto success = cryptoOperationDataFromJSValue(&state, state.uncheckedArgument(2), data);
ASSERT(scope.exception() || success);
if (!success)
return jsUndefined();
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);
};
auto result = algorithm->sign(*parameters, *key, data, WTFMove(successCallback), WTFMove(failureCallback));
if (result.hasException()) {
propagateException(state, scope, result.releaseException());
return { };
}
return promise;
}
Ref<CSSValueList> SVGFontFaceSrcElement::srcValue() const
{
Ref<CSSValueList> list = CSSValueList::createCommaSeparated();
for (auto& child : childrenOfType<SVGElement>(*this)) {
RefPtr<CSSFontFaceSrcValue> srcValue;
if (is<SVGFontFaceUriElement>(child))
srcValue = downcast<SVGFontFaceUriElement>(child).srcValue();
else if (is<SVGFontFaceNameElement>(child))
srcValue = downcast<SVGFontFaceNameElement>(child).srcValue();
if (srcValue && srcValue->resource().length())
list->append(srcValue.releaseNonNull());
}
return list;
}
void InbandMetadataTextTrackPrivateAVF::addDataCue(const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation> prpCueData, const String& type)
{
ASSERT(cueFormat() == Data);
ASSERT(start >= MediaTime::zeroTime());
if (!client())
return;
RefPtr<SerializedPlatformRepresentation> cueData = prpCueData;
m_currentCueStartTime = start;
if (end.isPositiveInfinite())
m_incompleteCues.append(IncompleteMetaDataCue { cueData.get(), start });
client()->addDataCue(start, end, cueData.releaseNonNull(), type);
}
void TextAutoSizingValue::reset()
{
HashSet<RefPtr<Node> >::iterator end = m_autoSizedNodes.end();
for (HashSet<RefPtr<Node> >::iterator i = m_autoSizedNodes.begin(); i != end; ++i) {
const RefPtr<Node>& autoSizingNode = *i;
RenderText* text = static_cast<RenderText*>(autoSizingNode->renderer());
if (!text)
continue;
// Reset the font size back to the original specified size
FontDescription fontDescription = text->style().fontDescription();
float originalSize = fontDescription.specifiedSize();
if (fontDescription.computedSize() != originalSize) {
fontDescription.setComputedSize(originalSize);
RefPtr<RenderStyle> style = cloneRenderStyleWithState(text->style());
style->setFontDescription(fontDescription);
style->font().update(autoSizingNode->document().ensureStyleResolver().fontSelector());
text->parent()->setStyle(style.releaseNonNull());
}
// Reset the line height of the parent.
RenderElement* parentRenderer = text->parent();
if (!parentRenderer)
continue;
if (parentRenderer->isAnonymousBlock())
parentRenderer = parentRenderer->parent();
const RenderStyle& parentStyle = parentRenderer->style();
Length originalLineHeight = parentStyle.specifiedLineHeight();
if (originalLineHeight != parentStyle.lineHeight()) {
RefPtr<RenderStyle> newParentStyle = cloneRenderStyleWithState(parentStyle);
newParentStyle->setLineHeight(originalLineHeight);
newParentStyle->setFontDescription(fontDescription);
newParentStyle->font().update(autoSizingNode->document().ensureStyleResolver().fontSelector());
parentRenderer->setStyle(newParentStyle.releaseNonNull());
}
}
}
void HTMLImageElement::createImageControls()
{
ASSERT(m_experimentalImageMenuEnabled);
ASSERT(!hasImageControls());
RefPtr<ImageControlsRootElement> imageControls = ImageControlsRootElement::maybeCreate(document());
if (!imageControls)
return;
ensureUserAgentShadowRoot().appendChild(imageControls.releaseNonNull());
auto* renderObject = renderer();
if (!renderObject)
return;
downcast<RenderImage>(*renderObject).setHasShadowControls(true);
}
SourceBuffer* MediaSource::addSourceBuffer(const String& type, ExceptionCode& ec)
{
LOG(Media, "MediaSource::addSourceBuffer(%s) %p", type.ascii().data(), this);
// 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
// 1. If type is null or an empty then throw an INVALID_ACCESS_ERR exception and
// abort these steps.
if (type.isNull() || type.isEmpty()) {
ec = INVALID_ACCESS_ERR;
return nullptr;
}
// 2. If type contains a MIME type that is not supported ..., then throw a
// NOT_SUPPORTED_ERR exception and abort these steps.
if (!isTypeSupported(type)) {
ec = NOT_SUPPORTED_ERR;
return nullptr;
}
// 4. If the readyState attribute is not in the "open" state then throw an
// INVALID_STATE_ERR exception and abort these steps.
if (!isOpen()) {
ec = INVALID_STATE_ERR;
return nullptr;
}
// 5. Create a new SourceBuffer object and associated resources.
ContentType contentType(type);
RefPtr<SourceBufferPrivate> sourceBufferPrivate = createSourceBufferPrivate(contentType, ec);
if (!sourceBufferPrivate) {
ASSERT(ec == NOT_SUPPORTED_ERR || ec == QUOTA_EXCEEDED_ERR);
// 2. If type contains a MIME type that is not supported ..., then throw a NOT_SUPPORTED_ERR exception and abort these steps.
// 3. If the user agent can't handle any more SourceBuffer objects then throw a QUOTA_EXCEEDED_ERR exception and abort these steps
return nullptr;
}
RefPtr<SourceBuffer> buffer = SourceBuffer::create(sourceBufferPrivate.releaseNonNull(), this);
// 6. Add the new object to sourceBuffers and fire a addsourcebuffer on that object.
m_sourceBuffers->add(buffer);
if (buffer->active())
m_activeSourceBuffers->add(buffer);
// 7. Return the new object to the caller.
return buffer.get();
}
Ref<WebKitNamedFlow> NamedFlowCollection::ensureFlowWithName(const String& flowName)
{
NamedFlowSet::iterator it = m_namedFlows.find<String, NamedFlowHashTranslator>(flowName);
if (it != m_namedFlows.end()) {
WebKitNamedFlow* namedFlow = *it;
ASSERT(namedFlow->flowState() == WebKitNamedFlow::FlowStateNull);
return *namedFlow;
}
RefPtr<WebKitNamedFlow> newFlow = WebKitNamedFlow::create(this, flowName);
m_namedFlows.add(newFlow.get());
InspectorInstrumentation::didCreateNamedFlow(document(), *newFlow);
return newFlow.releaseNonNull();
}
Ref<Node> HTMLTemplateElement::cloneNodeInternal(Document& targetDocument, CloningOperation type)
{
RefPtr<Node> clone;
switch (type) {
case CloningOperation::OnlySelf:
return cloneElementWithoutChildren(targetDocument);
case CloningOperation::SelfWithTemplateContent:
clone = cloneElementWithoutChildren(targetDocument);
break;
case CloningOperation::Everything:
clone = cloneElementWithChildren(targetDocument);
break;
}
if (m_content)
content()->cloneChildNodes(*downcast<HTMLTemplateElement>(clone.get())->content());
return clone.releaseNonNull();
}
