CSS Parser: Implement parseRule

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/CSSStyleSheet.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/css/parser/CSSPropertyParser.h"
+#include "core/css/parser/CSSSelectorParser.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/UseCounter.h"
 #include "wtf/BitArray.h"
 
 namespace blink {
 
 CSSParserImpl::CSSParserImpl(const CSSParserContext& context, const String& s)
 : m_context(context)
@@ skipping 58 matching lines @@
     CSSRuleSourceData::Type ruleType = CSSRuleSourceData::STYLE_RULE;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
         ruleType = CSSRuleSourceData::VIEWPORT_RULE;
     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)
+{
+    CSSParserImpl parser(context, string);
+    CSSParserTokenRange range(parser.m_tokens);
+    range.consumeWhitespaceAndComments();
+    if (range.atEnd())
+        return nullptr; // Parser error, empty rule
+    RefPtrWillBeRawPtr<StyleRuleBase> rule;
+    if (range.peek().type() == AtKeywordToken)
+        rule = parser.consumeAtRule(range);
+    else
+        rule = parser.consumeQualifiedRule(range);
+    if (!rule)
+        return nullptr; // Parser error, failed to consume rule
+    range.consumeWhitespaceAndComments();
+    if (!rule || !range.atEnd())
+        return nullptr; // Parser error, trailing garbage
+    return rule;
+}
+
+PassRefPtrWillBeRawPtr<StyleRuleBase> CSSParserImpl::consumeAtRule(CSSParserTokenRange& range)
+{
+    // FIXME: Implement at-rule parsing
+    return nullptr;
+}
+
+PassRefPtrWillBeRawPtr<StyleRuleBase> CSSParserImpl::consumeQualifiedRule(CSSParserTokenRange& range)
+{
+    const CSSParserToken* preludeStart = &range.peek();
+    while (!range.atEnd()) {
+        if (range.peek().type() == LeftBraceToken) {
+            CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
+            CSSParserTokenRange block = range.consumeBlock();
+
+            CSSSelectorList selectorList;
+            CSSSelectorParser::parseSelector(prelude, m_context, selectorList);
+            if (!selectorList.isValid())
+                return nullptr; // Parser error, invalid selector list
+            consumeDeclarationList(block, CSSRuleSourceData::STYLE_RULE);
+
+            RefPtrWillBeRawPtr<StyleRule> rule = StyleRule::create();
+            rule->wrapperAdoptSelectorList(selectorList);
+            rule->setProperties(createStylePropertySet(m_parsedProperties, m_context.mode()));
+            m_parsedProperties.clear();

[Timothy Loh, 2014/12/16 00:01:20]

This doesn't make a difference right now, but when we can parse rule lists we'll
need this. I might eventually make this not a member.

+            return rule.release();
+        }
+        range.consumeComponentValue();
+    }
+    return nullptr;
+}
+
 void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range, CSSRuleSourceData::Type ruleType)
 {
     while (!range.atEnd()) {
         switch (range.peek().type()) {
         case CommentToken:
         case WhitespaceToken:
         case SemicolonToken:
             range.consume();
             break;
         case IdentToken: {
@@ skipping 38 matching lines @@
 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID propertyID, bool important, CSSRuleSourceData::Type ruleType)
 {
     CSSParserValueList valueList(range);
     if (!valueList.size())
         return; // Parser error
     bool inViewport = ruleType == CSSRuleSourceData::VIEWPORT_RULE;
     CSSPropertyParser::parseValue(propertyID, important, &valueList, m_context, inViewport, m_parsedProperties, ruleType);
 }
 
 } // namespace blink