CSS Parser: Implement selector parsing (attributes) [2/3]

Source/core/css/parser/CSSSelectorParser.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/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 199 matching lines @@
     const String& value = m_tokenRange.consumeIncludingComments().value();
     if (isQuirksModeBehavior(m_context.mode()))
         selector->setValue(AtomicString(value.lower()));
     else
         selector->setValue(AtomicString(value));
     return selector.release();
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeAttribute()
 {
-    // FIXME: Implement attribute parsing
-    return nullptr;
+    ASSERT(m_tokenRange.peek().type() == LeftBracketToken);
+    m_tokenRange.consumeIncludingWhitespaceAndComments();
+
+    AtomicString namespacePrefix;
+    AtomicString attributeName;
+    bool hasNamespace;
+    if (!consumeName(attributeName, namespacePrefix, hasNamespace))
+        return nullptr;
+
+    if (m_context.isHTMLDocument())
+        attributeName = attributeName.lower();
+
+    QualifiedName qualifiedName = hasNamespace
+        ? determineNameInNamespace(namespacePrefix, attributeName)
+        : QualifiedName(nullAtom, attributeName, nullAtom);
+
+    OwnPtr<CSSParserSelector> selector = CSSParserSelector::create();
+
+    if (m_tokenRange.atEnd() || m_tokenRange.peek().type() == RightBracketToken) {
+        m_tokenRange.consumeIncludingComments();
+        selector->setAttribute(qualifiedName, CSSSelector::CaseSensitive);
+        selector->setMatch(CSSSelector::AttributeSet);
+        return selector.release();
+    }
+
+    selector->setMatch(consumeAttributeMatch());
+
+    const CSSParserToken& attributeValue = m_tokenRange.consumeIncludingWhitespaceAndComments();
+    if (attributeValue.type() != IdentToken && attributeValue.type() != StringToken)
+        return nullptr;
+    selector->setValue(AtomicString(attributeValue.value()));
+    selector->setAttribute(qualifiedName, consumeAttributeFlags());
+
+    if (!m_tokenRange.atEnd() && m_tokenRange.consumeIncludingComments().type() != RightBracketToken)
+        return nullptr;
+
+    return selector.release();
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumePseudo()
 {
     // FIXME: Implement pseudo-element and pseudo-class parsing
     return nullptr;
 }
 
 CSSSelector::Relation CSSSelectorParser::consumeCombinator()
 {
@@ skipping 23 matching lines @@
     m_tokenRange.consumeIncludingComments();
     const CSSParserToken& ident = m_tokenRange.consumeIncludingComments();
     if (ident.type() != IdentToken || !equalIgnoringCase(ident.value(), "deep"))
         m_failedParsing = true;
     const CSSParserToken& slash = m_tokenRange.consumeIncludingWhitespaceAndComments();
     if (slash.type() != DelimiterToken || slash.delimiter() != '/')
         m_failedParsing = true;
     return CSSSelector::ShadowDeep;
 }
 
+CSSSelector::Match CSSSelectorParser::consumeAttributeMatch()
+{
+    const CSSParserToken& token = m_tokenRange.consumeIncludingWhitespaceAndComments();
+    switch (token.type()) {
+    case IncludeMatchToken:
+        return CSSSelector::AttributeList;
+    case DashMatchToken:
+        return CSSSelector::AttributeHyphen;
+    case PrefixMatchToken:
+        return CSSSelector::AttributeBegin;
+    case SuffixMatchToken:
+        return CSSSelector::AttributeEnd;
+    case SubstringMatchToken:
+        return CSSSelector::AttributeContain;
+    case DelimiterToken:
+        if (token.delimiter() == '=')
+            return CSSSelector::AttributeExact;
+    default:
+        m_failedParsing = true;
+        return CSSSelector::AttributeExact;
+    }
+}
+
+CSSSelector::AttributeMatchType CSSSelectorParser::consumeAttributeFlags()
+{
+    if (m_tokenRange.peek().type() != IdentToken)
+        return CSSSelector::CaseSensitive;
+    const CSSParserToken& flag = m_tokenRange.consumeIncludingWhitespaceAndComments();
+    if (flag.value() == "i") {
+        if (RuntimeEnabledFeatures::cssAttributeCaseSensitivityEnabled() || isUASheetBehavior(m_context.mode()))
+            return CSSSelector::CaseInsensitive;
+    }
+    m_failedParsing = true;
+    return CSSSelector::CaseSensitive;
+}
+
 QualifiedName CSSSelectorParser::determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName)
 {
     if (!m_styleSheet)
         return QualifiedName(prefix, localName, m_defaultNamespace);
     return QualifiedName(prefix, localName, m_styleSheet->determineNamespace(prefix));
 }
 
 void CSSSelectorParser::rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector* specifiers)
 {
     if (m_defaultNamespace != starAtom || specifiers->crossesTreeScopes())
@@ skipping 82 matching lines @@
     }
     if (specifiers->isContentPseudoElement()) {
         specifiers->insertTagHistory(CSSSelector::SubSelector, newSpecifier, CSSSelector::SubSelector);
         return specifiers;
     }
     specifiers->appendTagHistory(CSSSelector::SubSelector, newSpecifier);
     return specifiers;
 }
 
 } // namespace blink