StyleRuleBase* BisonCSSParser::createFontFaceRule()
{
m_allowImportRules = m_allowNamespaceDeclarations = false;
for (unsigned i = 0; i < m_parsedProperties.size(); ++i) {
CSSProperty& property = m_parsedProperties[i];
if (property.id() == CSSPropertyFontVariant && property.value()->isPrimitiveValue())
property.wrapValueInCommaSeparatedList();
else if (property.id() == CSSPropertyFontFamily && (!property.value()->isValueList() || toCSSValueList(property.value())->length() != 1)) {
// Unlike font-family property, font-family descriptor in @font-face rule
// has to be a value list with exactly one family name. It cannot have a
// have 'initial' value and cannot 'inherit' from parent.
// See http://dev.w3.org/csswg/css3-fonts/#font-family-desc
clearProperties();
return 0;
}
}
RefPtrWillBeRawPtr<StyleRuleFontFace> rule = StyleRuleFontFace::create();
rule->setProperties(createStylePropertySet());
clearProperties();
StyleRuleFontFace* result = rule.get();
m_parsedRules.append(rule.release());
if (m_styleSheet)
m_styleSheet->setHasFontFaceRule(true);
return result;
}
PassRefPtrWillBeRawPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
{
OwnPtr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
if (!keyList)
return nullptr;
consumeDeclarationList(block, StyleRule::Keyframes);
return StyleRuleKeyframe::create(keyList.release(), createStylePropertySet(m_parsedProperties, m_context.mode()));
}
PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> CSSParserImpl::parseInlineStyleDeclaration(const String& string, Element* element)
{
Document& document = element->document();
CSSParserContext context = CSSParserContext(document.elementSheet().contents()->parserContext(), UseCounter::getFrom(&document));
CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode() ? HTMLStandardMode : HTMLQuirksMode;
context.setMode(mode);
CSSParserImpl parser(context, document.elementSheet().contents());
CSSTokenizer::Scope scope(string);
parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style);
return createStylePropertySet(parser.m_parsedProperties, mode);
}
PassRefPtrWillBeRawPtr<StyleRulePage> CSSParserImpl::consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
{
// We only support a small subset of the css-page spec.
prelude.consumeWhitespace();
AtomicString typeSelector;
if (prelude.peek().type() == IdentToken)
typeSelector = prelude.consume().value();
AtomicString pseudo;
if (prelude.peek().type() == ColonToken) {
prelude.consume();
if (prelude.peek().type() != IdentToken)
return nullptr; // Parse error; expected ident token following colon in @page header
pseudo = prelude.consume().value();
}
prelude.consumeWhitespace();
if (!prelude.atEnd())
return nullptr; // Parse error; extra tokens in @page header
OwnPtr<CSSParserSelector> selector;
if (!typeSelector.isNull() && pseudo.isNull()) {
selector = CSSParserSelector::create(QualifiedName(nullAtom, typeSelector, m_defaultNamespace));
} else {
selector = CSSParserSelector::create();
if (!pseudo.isNull()) {
selector->setMatch(CSSSelector::PagePseudoClass);
selector->setValue(pseudo.lower());
if (selector->pseudoType() == CSSSelector::PseudoUnknown)
return nullptr; // Parse error; unknown page pseudo-class
}
if (!typeSelector.isNull())
selector->prependTagSelector(QualifiedName(nullAtom, typeSelector, m_defaultNamespace));
}
if (m_observerWrapper) {
unsigned endOffset = m_observerWrapper->endOffset(prelude);
m_observerWrapper->observer().startRuleHeader(StyleRule::Page, m_observerWrapper->startOffset(prelude));
m_observerWrapper->observer().endRuleHeader(endOffset);
}
selector->setForPage();
RefPtrWillBeRawPtr<StyleRulePage> pageRule = StyleRulePage::create();
Vector<OwnPtr<CSSParserSelector>> selectorVector;
selectorVector.append(selector.release());
pageRule->parserAdoptSelectorVector(selectorVector);
consumeDeclarationList(block, StyleRule::Style);
pageRule->setProperties(createStylePropertySet(m_parsedProperties, m_context.mode()));
m_parsedProperties.clear();
return pageRule.release();
}
PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> BisonCSSParser::parseDeclaration(const String& string, StyleSheetContents* contextStyleSheet)
{
setStyleSheet(contextStyleSheet);
setupParser("@-internal-decls ", string, "");
cssyyparse(this);
m_rule = nullptr;
RefPtrWillBeRawPtr<ImmutableStylePropertySet> style = createStylePropertySet();
clearProperties();
return style.release();
}
PassRefPtrWillBeRawPtr<StyleRule> CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
{
CSSSelectorList selectorList;
CSSSelectorParser::parseSelector(prelude, m_context, m_styleSheet, selectorList);
if (!selectorList.isValid())
return nullptr; // Parse error, invalid selector list
if (m_observerWrapper)
observeSelectors(*m_observerWrapper, prelude);
consumeDeclarationList(block, StyleRule::Style);
return StyleRule::create(selectorList, createStylePropertySet(m_parsedProperties, m_context.mode()));
}
StyleRuleBase* BisonCSSParser::createStyleRule(Vector<OwnPtr<CSSParserSelector>>* selectors)
{
StyleRule* result = 0;
if (selectors) {
m_allowImportRules = m_allowNamespaceDeclarations = false;
RefPtrWillBeRawPtr<StyleRule> rule = StyleRule::create();
rule->parserAdoptSelectorVector(*selectors);
rule->setProperties(createStylePropertySet());
result = rule.get();
m_parsedRules.append(rule.release());
CSSSelectorParser::recordSelectorStats(m_context, result->selectorList());
}
clearProperties();
return result;
}
StyleRuleKeyframe* BisonCSSParser::createKeyframe(CSSParserValueList* keys)
{
OwnPtr<Vector<double>> keyVector = StyleRuleKeyframe::createKeyList(keys);
if (keyVector->isEmpty())
return 0;
RefPtrWillBeRawPtr<StyleRuleKeyframe> keyframe = StyleRuleKeyframe::create();
keyframe->setKeys(keyVector.release());
keyframe->setProperties(createStylePropertySet());
clearProperties();
StyleRuleKeyframe* keyframePtr = keyframe.get();
m_parsedKeyframes.append(keyframe.release());
return keyframePtr;
}
StyleRuleBase* BisonCSSParser::createPageRule(PassOwnPtr<CSSParserSelector> pageSelector)
{
// FIXME: Margin at-rules are ignored.
m_allowImportRules = m_allowNamespaceDeclarations = false;
StyleRulePage* pageRule = 0;
if (pageSelector) {
RefPtrWillBeRawPtr<StyleRulePage> rule = StyleRulePage::create();
Vector<OwnPtr<CSSParserSelector>> selectorVector;
selectorVector.append(pageSelector);
rule->parserAdoptSelectorVector(selectorVector);
rule->setProperties(createStylePropertySet());
pageRule = rule.get();
m_parsedRules.append(rule.release());
}
clearProperties();
return pageRule;
}
StyleRuleBase* BisonCSSParser::createViewportRule()
{
// Allow @viewport rules from UA stylesheets even if the feature is disabled.
if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_context.mode()))
return 0;
m_allowImportRules = m_allowNamespaceDeclarations = false;
RefPtrWillBeRawPtr<StyleRuleViewport> rule = StyleRuleViewport::create();
rule->setProperties(createStylePropertySet());
clearProperties();
StyleRuleViewport* result = rule.get();
m_parsedRules.append(rule.release());
return result;
}
PassRefPtrWillBeRawPtr<StyleRuleFontFace> CSSParserImpl::consumeFontFaceRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
{
prelude.consumeWhitespace();
if (!prelude.atEnd())
return nullptr; // Parse error; @font-face prelude should be empty
if (m_observerWrapper) {
unsigned endOffset = m_observerWrapper->endOffset(prelude);
m_observerWrapper->observer().startRuleHeader(StyleRule::FontFace, m_observerWrapper->startOffset(prelude));
m_observerWrapper->observer().endRuleHeader(endOffset);
m_observerWrapper->observer().startRuleBody(endOffset);
m_observerWrapper->observer().endRuleBody(endOffset);
}
if (m_styleSheet)
m_styleSheet->setHasFontFaceRule(true);
consumeDeclarationList(block, StyleRule::FontFace);
return StyleRuleFontFace::create(createStylePropertySet(m_parsedProperties, m_context.mode()));
}
PassRefPtrWillBeRawPtr<StyleRuleViewport> CSSParserImpl::consumeViewportRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
{
// Allow @viewport rules from UA stylesheets even if the feature is disabled.
if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_context.mode()))
return nullptr;
prelude.consumeWhitespace();
if (!prelude.atEnd())
return nullptr; // Parser error; @viewport prelude should be empty
if (m_observerWrapper) {
unsigned endOffset = m_observerWrapper->endOffset(prelude);
m_observerWrapper->observer().startRuleHeader(StyleRule::Viewport, m_observerWrapper->startOffset(prelude));
m_observerWrapper->observer().endRuleHeader(endOffset);
m_observerWrapper->observer().startRuleBody(endOffset);
m_observerWrapper->observer().endRuleBody(endOffset);
}
consumeDeclarationList(block, StyleRule::Viewport);
return StyleRuleViewport::create(createStylePropertySet(m_parsedProperties, CSSViewportRuleMode));
}
