Enable support for CSS Conditional Rules

Source/core/css/CSSParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 272 matching lines @@
         && a.isCSSGridLayoutEnabled == b.isCSSGridLayoutEnabled
         && a.isCSSVariablesEnabled == b.isCSSVariablesEnabled
         && a.needsSiteSpecificQuirks == b.needsSiteSpecificQuirks;
 }
 
 CSSParser::CSSParser(const CSSParserContext& context)
     : m_context(context)
     , m_important(false)
     , m_id(CSSPropertyInvalid)
     , m_styleSheet(0)
-#if ENABLE(CSS3_CONDITIONAL_RULES)
     , m_supportsCondition(false)
-#endif
     , m_selectorListForParseSelector(0)
     , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
     , m_hasFontFaceOnlyValues(false)
     , m_hadSyntacticallyValidCSSRule(false)
     , m_logErrors(false)
     , m_inFilterRule(false)
     , m_defaultNamespace(starAtom)
@@ skipping 155 matching lines @@
 }
 
 PassRefPtr<StyleKeyframe> CSSParser::parseKeyframeRule(StyleSheetContents* sheet, const String& string)
 {
     setStyleSheet(sheet);
     setupParser("@-webkit-keyframe-rule{ ", string, "} ");
     cssyyparse(this);
     return m_keyframe.release();
 }
 
-#if ENABLE(CSS3_CONDITIONAL_RULES)
 bool CSSParser::parseSupportsCondition(const String& string)
 {
     m_supportsCondition = false;
     setupParser("@-webkit-supports-condition{ ", string, "} ");
     cssyyparse(this);
     return m_supportsCondition;
 }
-#endif
 
 static inline bool isColorPropertyID(CSSPropertyID propertyId)
 {
     switch (propertyId) {
     case CSSPropertyColor:
     case CSSPropertyBackgroundColor:
     case CSSPropertyBorderBottomColor:
     case CSSPropertyBorderLeftColor:
     case CSSPropertyBorderRightColor:
     case CSSPropertyBorderTopColor:
@@ skipping 9694 matching lines @@
                 m_token = RIGHTTOP_SYM;
         } else if (length == 13) {
             // Checking the last character first could further reduce the possibile cases.
             if (isASCIIAlphaCaselessEqual(name[12], 'e') && isEqualToCSSIdentifier(name + 2, "ight-middl"))
                 m_token = RIGHTMIDDLE_SYM;
             else if (isASCIIAlphaCaselessEqual(name[12], 'm') && isEqualToCSSIdentifier(name + 2, "ight-botto"))
                 m_token = RIGHTBOTTOM_SYM;
         }
         return;
 
-#if ENABLE(CSS3_CONDITIONAL_RULES)
     case 's':
         if (length == 9 && isEqualToCSSIdentifier(name + 2, "upports")) {
             m_parsingMode = SupportsMode;
             m_token = SUPPORTS_SYM;
         }
         return;
-#endif
 
     case 't':
         if (hasEscape)
             return;
 
         switch (length) {
         case 9:
             if (isEqualToCSSIdentifier(name + 2, "op-left"))
                 m_token = TOPLEFT_SYM;
             return;
@@ skipping 80 matching lines @@
                 m_token = WEBKIT_MEDIAQUERY_SYM;
             }
             return;
 
         case 22:
             if (!hasEscape && isEqualToCSSIdentifier(name + 2, "webkit-keyframe-rule"))
                 m_token = WEBKIT_KEYFRAME_RULE_SYM;
             return;
 
         case 27:
-#if ENABLE(CSS3_CONDITIONAL_RULES)
             if (isEqualToCSSIdentifier(name + 2, "webkit-supports-condition")) {
                 m_parsingMode = SupportsMode;
                 m_token = WEBKIT_SUPPORTS_CONDITION_SYM;
             }
-#endif
             return;
         }
     }
 }
 
-#if ENABLE(CSS3_CONDITIONAL_RULES)
 template <typename CharacterType>
 inline void CSSParser::detectSupportsToken(int length)
 {
     ASSERT(m_parsingMode == SupportsMode);
     CharacterType* name = tokenStart<CharacterType>();
 
     if (length == 2) {
         if (isASCIIAlphaCaselessEqual(name[0], 'o') && isASCIIAlphaCaselessEqual(name[1], 'r'))
             m_token = SUPPORTS_OR;
     } else if (length == 3) {
         if (isASCIIAlphaCaselessEqual(name[0], 'a') && isASCIIAlphaCaselessEqual(name[1], 'n') && isASCIIAlphaCaselessEqual(name[2], 'd'))
             m_token = SUPPORTS_AND;
         else if (isASCIIAlphaCaselessEqual(name[0], 'n') && isASCIIAlphaCaselessEqual(name[1], 'o') && isASCIIAlphaCaselessEqual(name[2], 't'))
             m_token = SUPPORTS_NOT;
     }
 }
-#endif
 
 template <typename SrcCharacterType>
 int CSSParser::realLex(void* yylvalWithoutType)
 {
     YYSTYPE* yylval = static_cast<YYSTYPE*>(yylvalWithoutType);
     // Write pointer for the next character.
     SrcCharacterType* result;
     CSSParserString resultString;
     bool hasEscape;
 
@@ skipping 20 matching lines @@
                 break;
             }
         // Fall through to CharacterIdentifierStart.
 
     case CharacterIdentifierStart:
         --currentCharacter<SrcCharacterType>();
         parseIdentifier(result, yylval->string, hasEscape);
         m_token = IDENT;
 
         if (UNLIKELY(*currentCharacter<SrcCharacterType>() == '(')) {
-#if ENABLE(CSS3_CONDITIONAL_RULES)
             if (m_parsingMode == SupportsMode && !hasEscape) {
                 detectSupportsToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
                 if (m_token != IDENT)
                     break;
             }
-#endif
+
             m_token = FUNCTION;
             bool shouldSkipParenthesis = true;
             if (!hasEscape) {
                 bool detected = detectFunctionTypeToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
                 if (!detected && m_parsingMode == MediaQueryMode) {
                     // ... and(max-width: 480px) ... looks like a function, but in fact it is not,
                     // so run more detection code in the MediaQueryMode.
                     detectMediaQueryToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
                     shouldSkipParenthesis = false;
                 }
             }
 
             if (LIKELY(shouldSkipParenthesis)) {
                 ++currentCharacter<SrcCharacterType>();
                 ++result;
                 ++yylval->string.m_length;
             }
 
             if (token() == URI) {
                 m_token = FUNCTION;
                 // Check whether it is really an URI.
                 if (yylval->string.is8Bit())
                     parseURI<LChar>(yylval->string);
                 else
                     parseURI<UChar>(yylval->string);
             }
         } else if (UNLIKELY(m_parsingMode != NormalMode) && !hasEscape) {
             if (m_parsingMode == MediaQueryMode)
                 detectMediaQueryToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
-#if ENABLE(CSS3_CONDITIONAL_RULES)
             else if (m_parsingMode == SupportsMode)
                 detectSupportsToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
-#endif
             else if (m_parsingMode == NthChildMode && isASCIIAlphaCaselessEqual(tokenStart<SrcCharacterType>()[0], 'n')) {
                 if (result - tokenStart<SrcCharacterType>() == 1) {
                     // String "n" is IDENT but "n+1" is NTH.
                     if (parseNthChildExtra<SrcCharacterType>()) {
                         m_token = NTH;
                         yylval->string.m_length = currentCharacter<SrcCharacterType>() - tokenStart<SrcCharacterType>();
                     }
                 } else if (result - tokenStart<SrcCharacterType>() >= 2 && tokenStart<SrcCharacterType>()[1] == '-') {
                     // String "n-" is IDENT but "n-1" is NTH.
                     // Set currentCharacter to '-' to continue parsing.
@@ skipping 481 matching lines @@
     else {
         RuleList emptyRules;
         rule = StyleRuleMedia::create(media ? media : MediaQuerySet::create(), emptyRules);
     }
     StyleRuleMedia* result = rule.get();
     m_parsedRules.append(rule.release());
     endRuleBody();
     return result;
 }
 
-#if ENABLE(CSS3_CONDITIONAL_RULES)
 StyleRuleBase* CSSParser::createSupportsRule(bool conditionIsSupported, RuleList* rules)
 {
     m_allowImportRules = m_allowNamespaceDeclarations = false;
 
     RefPtr<CSSRuleSourceData> data = popSupportsRuleData();
     RefPtr<StyleRuleSupports> rule;
     String conditionText;
     unsigned conditionOffset = data->ruleHeaderRange.start + 9;
     unsigned conditionLength = data->ruleHeaderRange.length() - 9;
 
@@ skipping 37 matching lines @@
 }
 
 PassRefPtr<CSSRuleSourceData> CSSParser::popSupportsRuleData()
 {
     ASSERT(m_supportsRuleDataStack && !m_supportsRuleDataStack->isEmpty());
     RefPtr<CSSRuleSourceData> data = m_supportsRuleDataStack->last();
     m_supportsRuleDataStack->removeLast();
     return data.release();
 }
 
-#endif
-
 CSSParser::RuleList* CSSParser::createRuleList()
 {
     OwnPtr<RuleList> list = adoptPtr(new RuleList);
     RuleList* listPtr = list.get();
 
     m_parsedRuleLists.append(list.release());
     return listPtr;
 }
 
 void CSSParser::syntaxError(const Location& location, SyntaxErrorType error)
@@ skipping 746 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }