CSS Parser: Mark on stylesheets whether the first rule was valid

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 106 matching lines @@
     range.consumeWhitespace();
     if (!rule || !range.atEnd())
         return nullptr; // Parse error, trailing garbage
     return rule;
 }
 
 void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet)
 {
     CSSParserImpl parser(context, styleSheet);
     CSSTokenizer::Scope scope(string);
-    parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](PassRefPtrWillBeRawPtr<StyleRuleBase> rule) {
+    bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](PassRefPtrWillBeRawPtr<StyleRuleBase> rule) {
         styleSheet->parserAppendRule(rule);
     });
+    styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
 }
 
 PassOwnPtr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
 {
     return consumeKeyframeKeyList(CSSTokenizer::Scope(keyList).tokenRange());
 }
 
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range)
 {
     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)
         return allowedRules;
     ASSERT(allowedRules <= CSSParserImpl::RegularRules);
     if (rule->isImportRule())
         return CSSParserImpl::AllowImportRules;
     if (rule->isNamespaceRule())
         return CSSParserImpl::AllowNamespaceRules;
     return CSSParserImpl::RegularRules;
 }
 
 template<typename T>
-void CSSParserImpl::consumeRuleList(CSSParserTokenRange range, RuleListType ruleListType, const T callback)
+bool CSSParserImpl::consumeRuleList(CSSParserTokenRange range, RuleListType ruleListType, const T callback)
 {
     AllowedRulesType allowedRules = RegularRules;
     switch (ruleListType) {
     case TopLevelRuleList:
         allowedRules = AllowCharsetRules;
         break;
     case RegularRuleList:
         allowedRules = RegularRules;
         break;
     case KeyframesRuleList:
         allowedRules = KeyframeRules;
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
+    bool seenRule = false;
+    bool firstRuleValid = false;
     while (!range.atEnd()) {
+        RefPtrWillBeRawPtr<StyleRuleBase> rule;
         switch (range.peek().type()) {
         case WhitespaceToken:
             range.consumeWhitespace();
-            break;
+            continue;
         case AtKeywordToken:
-            if (PassRefPtrWillBeRawPtr<StyleRuleBase> rule = consumeAtRule(range, allowedRules)) {
-                allowedRules = computeNewAllowedRules(allowedRules, rule.get());
-                callback(rule);
-            }
+            rule = consumeAtRule(range, allowedRules);
             break;
         case CDOToken:
         case CDCToken:
             if (ruleListType == TopLevelRuleList) {
                 range.consume();
-                break;
+                continue;
             }
             // fallthrough
         default:
-            if (PassRefPtrWillBeRawPtr<StyleRuleBase> rule = consumeQualifiedRule(range, allowedRules)) {
-                allowedRules = computeNewAllowedRules(allowedRules, rule.get());
-                callback(rule);
-            }
+            rule = consumeQualifiedRule(range, allowedRules);
             break;
         }
+        if (!seenRule) {
+            seenRule = true;
+            firstRuleValid = rule;
+        }
+        if (rule) {
+            allowedRules = computeNewAllowedRules(allowedRules, rule.get());
+            callback(rule.release());
+        }
     }
+
+    return firstRuleValid;
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleBase> CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, AllowedRulesType allowedRules)
 {
     ASSERT(range.peek().type() == AtKeywordToken);
     const CSSParserString& name = range.consume().value();
     const CSSParserToken* preludeStart = &range.peek();
     while (!range.atEnd() && range.peek().type() != LeftBraceToken && range.peek().type() != SemicolonToken)
         range.consumeComponentValue();
 
     CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
 
     if (range.atEnd() || range.peek().type() == SemicolonToken) {
         range.consume();
-        if (allowedRules == AllowCharsetRules && name.equalIgnoringCase("charset")) {
-            // @charset is actually parsed before we get into the CSS parser.
-            // In theory we should validate the prelude is a string, but we don't
-            // have error logging yet so it doesn't matter.
-            return nullptr;
-        }
+        if (allowedRules == AllowCharsetRules && name.equalIgnoringCase("charset"))
+            return consumeCharsetRule(prelude);
         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
@@ skipping 50 matching lines @@
         return AtomicString();
 
     CSSParserTokenRange contents = range.consumeBlock();
     const CSSParserToken& uri = contents.consumeIncludingWhitespace();
     ASSERT(uri.type() == StringToken);
     if (!contents.atEnd())
         return AtomicString();
     return uri.value();
 }
 
+PassRefPtrWillBeRawPtr<StyleRuleCharset> CSSParserImpl::consumeCharsetRule(CSSParserTokenRange prelude)
+{
+    prelude.consumeWhitespace();
+    const CSSParserToken& string = prelude.consumeIncludingWhitespace();
+    if (string.type() != StringToken || !prelude.atEnd())
+        return nullptr; // Parse error, expected a single string
+    return StyleRuleCharset::create();
+}
+
 PassRefPtrWillBeRawPtr<StyleRuleImport> CSSParserImpl::consumeImportRule(CSSParserTokenRange prelude)
 {
     prelude.consumeWhitespace();
     AtomicString uri(consumeStringOrURI(prelude));
     if (uri.isNull())
         return nullptr; // Parse error, expected string or URI
     return StyleRuleImport::create(uri, MediaQueryParser::parseMediaQuerySet(prelude));
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleNamespace> CSSParserImpl::consumeNamespaceRule(CSSParserTokenRange prelude)
@@ skipping 260 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