Remove all attribute selectors that are not Set or Exact.

sky/engine/core/css/SelectorChecker.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 68 matching lines @@
                 scope->treeScope() == m_element.treeScope() ||
                 m_element == scope->shadowHost();
         }
         current = current->tagHistory();
     }
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
-template<typename CharType>
-static inline bool containsHTMLSpaceTemplate(const CharType* string, unsigned length)
-{
-    for (unsigned i = 0; i < length; ++i)
-        if (isHTMLSpace<CharType>(string[i]))
-            return true;
-    return false;
-}
-
-static inline bool containsHTMLSpace(const AtomicString& string)
-{
-    if (LIKELY(string.is8Bit()))
-        return containsHTMLSpaceTemplate<LChar>(string.characters8(), string.length());
-    return containsHTMLSpaceTemplate<UChar>(string.characters16(), string.length());
-}
-
-static bool attributeValueMatches(const Attribute& attributeItem, CSSSelector::Match match, const AtomicString& selectorValue, bool caseSensitive)
-{
-    const AtomicString& value = attributeItem.value();
-    if (value.isNull())
-        return false;
-
-    switch (match) {
-    case CSSSelector::Exact:
-        if (caseSensitive ? selectorValue != value : !equalIgnoringCase(selectorValue, value))
-            return false;
-        break;
-    case CSSSelector::List:
-        {
-            // Ignore empty selectors or selectors containing HTML spaces
-            if (selectorValue.isEmpty() || containsHTMLSpace(selectorValue))
-                return false;
-
-            unsigned startSearchAt = 0;
-            while (true) {
-                size_t foundPos = value.find(selectorValue, startSearchAt, caseSensitive);
-                if (foundPos == kNotFound)
-                    return false;
-                if (!foundPos || isHTMLSpace<UChar>(value[foundPos - 1])) {
-                    unsigned endStr = foundPos + selectorValue.length();
-                    if (endStr == value.length() || isHTMLSpace<UChar>(value[endStr]))
-                        break; // We found a match.
-                }
-
-                // No match. Keep looking.
-                startSearchAt = foundPos + 1;
-            }
-            break;
-        }
-    case CSSSelector::Contain:
-        if (!value.contains(selectorValue, caseSensitive) || selectorValue.isEmpty())
-            return false;
-        break;
-    case CSSSelector::Begin:
-        if (!value.startsWith(selectorValue, caseSensitive) || selectorValue.isEmpty())
-            return false;
-        break;
-    case CSSSelector::End:
-        if (!value.endsWith(selectorValue, caseSensitive) || selectorValue.isEmpty())
-            return false;
-        break;
-    case CSSSelector::Hyphen:
-        if (value.length() < selectorValue.length())
-            return false;
-        if (!value.startsWith(selectorValue, caseSensitive))
-            return false;
-        // It they start the same, check for exact match or following '-':
-        if (value.length() != selectorValue.length() && value[selectorValue.length()] != '-')
-            return false;
-        break;
-    default:
-        break;
-    }
-
-    return true;
-}
-
 static bool anyAttributeMatches(const Element& element, CSSSelector::Match match, const CSSSelector& selector)
 {
     const QualifiedName& selectorAttr = selector.attribute();
     ASSERT(selectorAttr.localName() != starAtom); // Should not be possible from the CSS grammar.
 
-    // Synchronize the attribute in case it is lazy-computed.
-    element.synchronizeAttribute(selectorAttr.localName());
+    if (match == CSSSelector::Set)
+        return element.hasAttribute(selectorAttr);
+
+    ASSERT(match == CSSSelector::Exact);
 
     const AtomicString& selectorValue = selector.value();
-    bool caseInsensitive = selector.attributeMatchType() == CSSSelector::CaseInsensitive;
+    const AtomicString& value = element.getAttribute(selectorAttr);
 
-    AttributeCollection attributes = element.attributesWithoutUpdate();
-    AttributeCollection::iterator end = attributes.end();
-    for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
-        const Attribute& attributeItem = *it;
-
-        if (!attributeItem.matches(selectorAttr))
-            continue;
-
-        if (attributeValueMatches(attributeItem, match, selectorValue, !caseInsensitive))
-            return true;
-    }
-
-    return false;
+    if (value.isNull())
+        return false;
+    if (selector.attributeMatchType() == CSSSelector::CaseInsensitive)
+        return equalIgnoringCase(selectorValue, value);
+    return selectorValue == value;
 }
 
 bool SelectorChecker::checkOne(const CSSSelector& selector, const ContainerNode* scope)
 {
     switch (selector.match()) {
     case CSSSelector::Tag:
         {
             const AtomicString& localName = selector.tagQName().localName();
             return localName == starAtom || localName == m_element.localName();
         }
     case CSSSelector::Class:
         return m_element.hasClass() && m_element.classNames().contains(selector.value());
     case CSSSelector::Id:
         return m_element.hasID() && m_element.idForStyleResolution() == selector.value();
     case CSSSelector::Exact:
     case CSSSelector::Set:
-    case CSSSelector::Hyphen:
-    case CSSSelector::List:
-    case CSSSelector::Contain:
-    case CSSSelector::Begin:
-    case CSSSelector::End:
         if (anyAttributeMatches(m_element, selector.match(), selector)) {
             m_matchedAttributeSelector = true;
             return true;
         }
         return false;
     case CSSSelector::PseudoClass:
         return checkPseudoClass(selector, scope);
     // FIXME(sky): Remove pseudo elements completely.
     case CSSSelector::PseudoElement:
     case CSSSelector::Unknown:
@@ skipping 56 matching lines @@
     case CSSSelector::PseudoUnknown:
     case CSSSelector::PseudoNotParsed:
     case CSSSelector::PseudoUserAgentCustomElement:
         return false;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 }