Make CSSRuleSourceData use the CSSRule Type enum

Source/core/css/parser/CSSParserImpl.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/css/parser/CSSParserImpl.h"
 
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/StylePropertySet.h"
@@ skipping 18 matching lines @@
 : m_context(context)
 , m_defaultNamespace(starAtom)
 , m_styleSheet(styleSheet)
 {
     CSSTokenizer::tokenize(string, m_tokens);
 }
 
 bool CSSParserImpl::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
 {
     CSSParserImpl parser(context, string);
-    CSSRuleSourceData::Type ruleType = CSSRuleSourceData::STYLE_RULE;
+    StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
-        ruleType = CSSRuleSourceData::VIEWPORT_RULE;
+        ruleType = StyleRule::Viewport;
     parser.consumeDeclarationValue(CSSParserTokenRange(parser.m_tokens), propertyID, important, ruleType);
     if (parser.m_parsedProperties.isEmpty())
         return false;
     declaration->addParsedProperties(parser.m_parsedProperties);
     return true;
 }
 
 static inline void filterProperties(bool important, const WillBeHeapVector<CSSProperty, 256>& input, WillBeHeapVector<CSSProperty, 256>& output, size_t& unusedEntries, BitArray<numCSSProperties>& seenProperties)
 {
     // Add properties in reverse order so that highest priority definitions are reached first. Duplicate definitions can then be ignored when found.
@@ skipping 21 matching lines @@
     return ImmutableStylePropertySet::create(results.data() + unusedEntries, results.size() - unusedEntries, 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, string);
-    parser.consumeDeclarationList(CSSParserTokenRange(parser.m_tokens), CSSRuleSourceData::STYLE_RULE);
+    parser.consumeDeclarationList(CSSParserTokenRange(parser.m_tokens), StyleRule::Style);
     return createStylePropertySet(parser.m_parsedProperties, mode);
 }
 
 bool CSSParserImpl::parseDeclaration(MutableStylePropertySet* declaration, const String& string, const CSSParserContext& context)
 {
     CSSParserImpl parser(context, string);
-    CSSRuleSourceData::Type ruleType = CSSRuleSourceData::STYLE_RULE;
+    StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
-        ruleType = CSSRuleSourceData::VIEWPORT_RULE;
+        ruleType = StyleRule::Viewport;
     parser.consumeDeclarationList(CSSParserTokenRange(parser.m_tokens), ruleType);
     if (parser.m_parsedProperties.isEmpty())
         return false;
     declaration->addParsedProperties(parser.m_parsedProperties);
     return true;
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleBase> CSSParserImpl::parseRule(const String& string, const CSSParserContext& context, AllowedRulesType allowedRules)
 {
     CSSParserImpl parser(context, string);
@@ skipping 25 matching lines @@
 PassOwnPtr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
 {
     Vector<CSSParserToken> tokens;
     CSSTokenizer::tokenize(keyList, tokens);
     return consumeKeyframeKeyList(tokens);
 }
 
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range)
 {
     ASSERT(m_parsedProperties.isEmpty());
-    consumeDeclaration(range, CSSRuleSourceData::STYLE_RULE);
+    consumeDeclaration(range, StyleRule::Style);
     bool result = !m_parsedProperties.isEmpty();
     m_parsedProperties.clear();
     return result;
 }
 
 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(CSSParserImpl::AllowedRulesType allowedRules, StyleRuleBase* rule)
 {
     if (!rule || allowedRules == CSSParserImpl::KeyframeRules)
         return allowedRules;
     ASSERT(allowedRules <= CSSParserImpl::RegularRules);
@@ skipping 189 matching lines @@
 
 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.consumeWhitespaceAndComments();
     if (!prelude.atEnd())
         return nullptr; // Parser error; @viewport prelude should be empty
-    consumeDeclarationList(block, CSSRuleSourceData::VIEWPORT_RULE);
+    consumeDeclarationList(block, StyleRule::Viewport);
     RefPtrWillBeRawPtr<StyleRuleViewport> rule = StyleRuleViewport::create();
     rule->setProperties(createStylePropertySet(m_parsedProperties, CSSViewportRuleMode));
     m_parsedProperties.clear();
     return rule.release();
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleFontFace> CSSParserImpl::consumeFontFaceRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     prelude.consumeWhitespaceAndComments();
     if (!prelude.atEnd())
         return nullptr; // Parse error; @font-face prelude should be empty
-    consumeDeclarationList(block, CSSRuleSourceData::FONT_FACE_RULE);
+    consumeDeclarationList(block, StyleRule::FontFace);
 
     // FIXME: This logic should be in CSSPropertyParser
     // FIXME: Shouldn't we fail if font-family or src aren't specified?
     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)) {
             m_parsedProperties.clear();
             return nullptr;
@@ skipping 70 matching lines @@
             selector->prependTagSelector(QualifiedName(nullAtom, typeSelector, m_defaultNamespace));
     }
 
     selector->setForPage();
 
     RefPtrWillBeRawPtr<StyleRulePage> pageRule = StyleRulePage::create();
     Vector<OwnPtr<CSSParserSelector>> selectorVector;
     selectorVector.append(selector.release());
     pageRule->parserAdoptSelectorVector(selectorVector);
 
-    consumeDeclarationList(block, CSSRuleSourceData::STYLE_RULE);
+    consumeDeclarationList(block, StyleRule::Style);
     pageRule->setProperties(createStylePropertySet(m_parsedProperties, m_context.mode()));
     m_parsedProperties.clear();
 
     return pageRule.release();
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     OwnPtr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
     if (!keyList)
         return nullptr;
-    consumeDeclarationList(block, CSSRuleSourceData::KEYFRAMES_RULE);
+    consumeDeclarationList(block, StyleRule::Keyframes);
     RefPtrWillBeRawPtr<StyleRuleKeyframe> rule = StyleRuleKeyframe::create();
     rule->setKeys(keyList.release());
     rule->setProperties(createStylePropertySet(m_parsedProperties, m_context.mode()));
     m_parsedProperties.clear();
     return rule.release();
 }
 
 PassRefPtrWillBeRawPtr<StyleRule> CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     CSSSelectorList selectorList;
     CSSSelectorParser::parseSelector(prelude, m_context, m_defaultNamespace, m_styleSheet, selectorList);
     if (!selectorList.isValid())
         return nullptr; // Parse error, invalid selector list
-    consumeDeclarationList(block, CSSRuleSourceData::STYLE_RULE);
+    consumeDeclarationList(block, StyleRule::Style);
 
     RefPtrWillBeRawPtr<StyleRule> rule = StyleRule::create();
     rule->wrapperAdoptSelectorList(selectorList);
     rule->setProperties(createStylePropertySet(m_parsedProperties, m_context.mode()));
     m_parsedProperties.clear();
     return rule.release();
 }
 
-void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range, CSSRuleSourceData::Type ruleType)
+void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range, StyleRule::Type ruleType)
 {
     ASSERT(m_parsedProperties.isEmpty());
 
     while (!range.atEnd()) {
         switch (range.peek().type()) {
         case CommentToken:
         case WhitespaceToken:
         case SemicolonToken:
             range.consume();
             break;
         case IdentToken: {
             const CSSParserToken* declarationStart = &range.peek();
             while (!range.atEnd() && range.peek().type() != SemicolonToken)
                 range.consumeComponentValue();
             consumeDeclaration(range.makeSubRange(declarationStart, &range.peek()), ruleType);
             break;
         }
         default: // Parser error
             // FIXME: The spec allows at-rules in a declaration list
             while (!range.atEnd() && range.peek().type() != SemicolonToken)
                 range.consumeComponentValue();
             break;
         }
     }
 }
 
-void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range, CSSRuleSourceData::Type ruleType)
+void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range, StyleRule::Type ruleType)
 {
     ASSERT(range.peek().type() == IdentToken);
     CSSPropertyID id = range.consumeIncludingWhitespaceAndComments().parseAsCSSPropertyID();
     if (id == CSSPropertyInvalid)
         return;
     if (range.consume().type() != ColonToken)
         return; // Parse error
 
     // FIXME: We shouldn't allow !important in @keyframes or @font-face
     const CSSParserToken* last = range.end() - 1;
     while (last->type() == WhitespaceToken || last->type() == CommentToken)
         --last;
     if (last->type() == IdentToken && equalIgnoringCase(last->value(), "important")) {
         --last;
         while (last->type() == WhitespaceToken || last->type() == CommentToken)
             --last;
         if (last->type() == DelimiterToken && last->delimiter() == '!') {
             consumeDeclarationValue(range.makeSubRange(&range.peek(), last), id, true, ruleType);
             return;
         }
     }
     consumeDeclarationValue(range.makeSubRange(&range.peek(), range.end()), id, false, ruleType);
 }
 
-void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID propertyID, bool important, CSSRuleSourceData::Type ruleType)
+void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID propertyID, bool important, StyleRule::Type ruleType)
 {
     CSSParserValueList valueList(range);
     if (!valueList.size())
         return; // Parser error
-    bool inViewport = ruleType == CSSRuleSourceData::VIEWPORT_RULE;
+    bool inViewport = ruleType == StyleRule::Viewport;
     CSSPropertyParser::parseValue(propertyID, important, &valueList, m_context, inViewport, m_parsedProperties, ruleType);
 }
 
 PassOwnPtr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenRange range)
 {
     OwnPtr<Vector<double>> result = adoptPtr(new Vector<double>);
     while (true) {
         range.consumeWhitespaceAndComments();
         const CSSParserToken& token = range.consumeIncludingWhitespaceAndComments();
         if (token.type() == PercentageToken && token.numericValue() >= 0 && token.numericValue() <= 100)
             result->append(token.numericValue() / 100);
         else if (token.type() == IdentToken && equalIgnoringCase(token.value(), "from"))
             result->append(0);
         else if (token.type() == IdentToken && equalIgnoringCase(token.value(), "to"))
             result->append(1);
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result.release();
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink