CSS Parser: Handle at-rules in declaration lists

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 130 matching lines @@
 {
     ASSERT(m_parsedProperties.isEmpty());
     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)
+    if (!rule || allowedRules == CSSParserImpl::KeyframeRules || allowedRules == CSSParserImpl::NoRules)
         return allowedRules;
     ASSERT(allowedRules <= CSSParserImpl::RegularRules);
     if (rule->isCharsetRule() || rule->isImportRule())
         return CSSParserImpl::AllowImportRules;
     if (rule->isNamespaceRule())
         return CSSParserImpl::AllowNamespaceRules;
     return CSSParserImpl::RegularRules;
 }
 
 template<typename T>
@@ skipping 66 matching lines @@
         if (allowedRules <= AllowImportRules && name.equalIgnoringCase("import"))
             return consumeImportRule(prelude);
         if (allowedRules <= AllowNamespaceRules && name.equalIgnoringCase("namespace"))
             return consumeNamespaceRule(prelude);
         return nullptr; // Parse error, unrecognised at-rule without block
     }
 
     CSSParserTokenRange block = range.consumeBlock();
     if (allowedRules == KeyframeRules)
         return nullptr; // Parse error, no at-rules supported inside @keyframes
+    if (allowedRules == NoRules)
+        return nullptr; // Parse error, no at-rules supported inside declaration lists
 
     ASSERT(allowedRules <= RegularRules);
 
     if (name.equalIgnoringCase("media"))
         return consumeMediaRule(prelude, block);
     if (name.equalIgnoringCase("supports"))
         return consumeSupportsRule(prelude, block);
     if (name.equalIgnoringCase("viewport"))
         return consumeViewportRule(prelude, block);
     if (name.equalIgnoringCase("font-face"))
@@ skipping 261 matching lines @@
         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
+        case AtKeywordToken: {
+            RefPtrWillBeRawPtr<StyleRuleBase> rule = consumeAtRule(range, NoRules);
+            ASSERT(!rule);
+            break;
+        }
+        default: // Parse error, unexpected token in declaration list
             while (!range.atEnd() && range.peek().type() != SemicolonToken)
                 range.consumeComponentValue();
             break;
         }
     }
 }
 
 void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range, StyleRule::Type ruleType)
 {
     ASSERT(range.peek().type() == IdentToken);
@@ skipping 46 matching lines @@
         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