PassRefPtrWillBeRawPtr<StyleRuleKeyframes> CSSParserImpl::consumeKeyframesRule(bool webkitPrefixed, CSSParserTokenRange prelude, CSSParserTokenRange block)
{
prelude.consumeWhitespace();
const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace();
if (!prelude.atEnd())
return nullptr; // Parse error; expected single non-whitespace token in @keyframes header
String name;
if (nameToken.type() == IdentToken) {
name = nameToken.value();
} else if (nameToken.type() == StringToken && webkitPrefixed) {
if (m_context.useCounter())
m_context.useCounter()->count(UseCounter::QuotedKeyframesRule);
name = nameToken.value();
} else {
return nullptr; // Parse error; expected ident token in @keyframes header
}
if (m_observerWrapper) {
unsigned endOffset = m_observerWrapper->endOffset(prelude);
m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframes, m_observerWrapper->startOffset(prelude));
m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));
m_observerWrapper->observer().startRuleBody(endOffset);
m_observerWrapper->observer().endRuleBody(endOffset);
}
RefPtrWillBeRawPtr<StyleRuleKeyframes> keyframeRule = StyleRuleKeyframes::create();
consumeRuleList(block, KeyframesRuleList, [keyframeRule](PassRefPtrWillBeRawPtr<StyleRuleBase> keyframe) {
keyframeRule->parserAppendKeyframe(toStyleRuleKeyframe(keyframe.get()));
});
keyframeRule->setName(name);
keyframeRule->setVendorPrefixed(webkitPrefixed);
return keyframeRule.release();
}
PassRefPtrWillBeRawPtr<StyleRuleKeyframe> CSSParser::parseKeyframeRule(const CSSParserContext& context, StyleSheetContents* styleSheet, const String& rule)
{
if (RuntimeEnabledFeatures::newCSSParserEnabled()) {
RefPtrWillBeRawPtr<StyleRuleBase> keyframe = CSSParserImpl::parseRule(rule, context, CSSParserImpl::KeyframeRules);
return toStyleRuleKeyframe(keyframe.get());
}
return BisonCSSParser(context).parseKeyframeRule(styleSheet, rule);
}
void StyleRuleBase::finalizeGarbageCollectedObject()
{
switch (type()) {
case Charset:
toStyleRuleCharset(this)->~StyleRuleCharset();
return;
case Style:
toStyleRule(this)->~StyleRule();
return;
case Page:
toStyleRulePage(this)->~StyleRulePage();
return;
case FontFace:
toStyleRuleFontFace(this)->~StyleRuleFontFace();
return;
case Media:
toStyleRuleMedia(this)->~StyleRuleMedia();
return;
case Supports:
toStyleRuleSupports(this)->~StyleRuleSupports();
return;
case Import:
toStyleRuleImport(this)->~StyleRuleImport();
return;
case Keyframes:
toStyleRuleKeyframes(this)->~StyleRuleKeyframes();
return;
case Keyframe:
toStyleRuleKeyframe(this)->~StyleRuleKeyframe();
return;
case Namespace:
toStyleRuleNamespace(this)->~StyleRuleNamespace();
return;
case Viewport:
toStyleRuleViewport(this)->~StyleRuleViewport();
return;
case Unknown:
return;
}
ASSERT_NOT_REACHED();
}
void StyleRuleBase::destroy()
{
switch (type()) {
case Charset:
delete toStyleRuleCharset(this);
return;
case Style:
delete toStyleRule(this);
return;
case Page:
delete toStyleRulePage(this);
return;
case FontFace:
delete toStyleRuleFontFace(this);
return;
case Media:
delete toStyleRuleMedia(this);
return;
case Supports:
delete toStyleRuleSupports(this);
return;
case Import:
delete toStyleRuleImport(this);
return;
case Keyframes:
delete toStyleRuleKeyframes(this);
return;
case Keyframe:
delete toStyleRuleKeyframe(this);
return;
case Namespace:
delete toStyleRuleNamespace(this);
return;
case Viewport:
delete toStyleRuleViewport(this);
return;
case Unknown:
return;
}
ASSERT_NOT_REACHED();
}
PassRefPtrWillBeRawPtr<StyleRuleKeyframe> CSSParser::parseKeyframeRule(const CSSParserContext& context, const String& rule)
{
RefPtrWillBeRawPtr<StyleRuleBase> keyframe = CSSParserImpl::parseRule(rule, context, nullptr, CSSParserImpl::KeyframeRules);
return toStyleRuleKeyframe(keyframe.get());
}
