Add support for case-insensitive attribute value selectors

Source/core/css/CSSSelector.cpp

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
  *               2001-2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 641 matching lines @@
 
             if (cs->pseudoType() == PseudoContent) {
                 if (cs->relation() == CSSSelector::SubSelector && cs->tagHistory())
                     return cs->tagHistory()->selectorText() + str.toString() + rightSide;
             }
         } else if (cs->isAttributeSelector()) {
             str.append('[');
             const AtomicString& prefix = cs->attribute().prefix();
             if (!prefix.isNull()) {
                 str.append(prefix);
-                str.append("|");
+                str.append('|');
             }
             str.append(cs->attribute().localName());
             switch (cs->m_match) {
                 case CSSSelector::Exact:
                     str.append('=');
                     break;
                 case CSSSelector::Set:
                     // set has no operator or value, just the attrName
                     str.append(']');
                     break;
@@ skipping 10 matching lines @@
                     str.appendLiteral("$=");
                     break;
                 case CSSSelector::Contain:
                     str.appendLiteral("*=");
                     break;
                 default:
                     break;
             }
             if (cs->m_match != CSSSelector::Set) {
                 serializeString(cs->value(), str);
+                if (cs->attributeFlags() & CaseInsensitive)
+                    str.appendLiteral(" i");
                 str.append(']');
             }
         }
         if (cs->relation() != CSSSelector::SubSelector || !cs->tagHistory())
             break;
         cs = cs->tagHistory();
     }
 
     if (const CSSSelector* tagHistory = cs->tagHistory()) {
         switch (cs->relation()) {
         case CSSSelector::Descendant:
             return tagHistory->selectorText(" " + str.toString() + rightSide);
         case CSSSelector::Child:
             return tagHistory->selectorText(" > " + str.toString() + rightSide);
         case CSSSelector::ShadowDeep:
             return tagHistory->selectorText(" /deep/ " + str.toString() + rightSide);
         case CSSSelector::DirectAdjacent:
             return tagHistory->selectorText(" + " + str.toString() + rightSide);
         case CSSSelector::IndirectAdjacent:
             return tagHistory->selectorText(" ~ " + str.toString() + rightSide);
         case CSSSelector::SubSelector:
             ASSERT_NOT_REACHED();
         case CSSSelector::ShadowPseudo:
             return tagHistory->selectorText(str.toString() + rightSide);
         }
     }
     return str.toString() + rightSide;
 }
 
-void CSSSelector::setAttribute(const QualifiedName& value)
+void CSSSelector::setAttribute(const QualifiedName& value, unsigned flags)
 {
     createRareData();
     m_data.m_rareData->m_attribute = value;
+    m_data.m_rareData->m_bits.m_attributeFlags = flags;
 }
 
 void CSSSelector::setArgument(const AtomicString& value)
 {
     createRareData();
     m_data.m_rareData->m_argument = value;
 }
 
 void CSSSelector::setSelectorList(PassOwnPtr<CSSSelectorList> selectorList)
 {
@@ skipping 83 matching lines @@
 }
 
 bool CSSSelector::matchNth(int count) const
 {
     ASSERT(m_hasRareData);
     return m_data.m_rareData->matchNth(count);
 }
 
 CSSSelector::RareData::RareData(const AtomicString& value)
     : m_value(value)
-    , m_a(0)
-    , m_b(0)
     , m_attribute(anyQName())
     , m_argument(nullAtom)
 {
 }
 
 CSSSelector::RareData::~RareData()
 {
 }
 
 // a helper function for parsing nth-arguments
 bool CSSSelector::RareData::parseNth()
 {
     String argument = m_argument.lower();
 
     if (argument.isEmpty())
         return false;
 
-    m_a = 0;
-    m_b = 0;
+    int nthA = 0;
+    int nthB = 0;
     if (argument == "odd") {
-        m_a = 2;
-        m_b = 1;
+        nthA = 2;
+        nthB = 1;
     } else if (argument == "even") {
-        m_a = 2;
-        m_b = 0;
+        nthA = 2;
+        nthB = 0;
     } else {
         size_t n = argument.find('n');
         if (n != kNotFound) {
             if (argument[0] == '-') {
                 if (n == 1)
-                    m_a = -1; // -n == -1n
+                    nthA = -1; // -n == -1n
                 else
-                    m_a = argument.substring(0, n).toInt();
-            } else if (!n)
-                m_a = 1; // n == 1n
-            else
-                m_a = argument.substring(0, n).toInt();
+                    nthA = argument.substring(0, n).toInt();
+            } else if (!n) {
+                nthA = 1; // n == 1n
+            } else {
+                nthA = argument.substring(0, n).toInt();
+            }
 
             size_t p = argument.find('+', n);
-            if (p != kNotFound)
-                m_b = argument.substring(p + 1, argument.length() - p - 1).toInt();
-            else {
+            if (p != kNotFound) {
+                nthB = argument.substring(p + 1, argument.length() - p - 1).toInt();
+            } else {
                 p = argument.find('-', n);
                 if (p != kNotFound)
-                    m_b = -argument.substring(p + 1, argument.length() - p - 1).toInt();
+                    nthB = -argument.substring(p + 1, argument.length() - p - 1).toInt();
             }
-        } else
-            m_b = argument.toInt();
+        } else {
+            nthB = argument.toInt();
+        }
     }
+    m_bits.m_nth.m_a = nthA;
+    m_bits.m_nth.m_b = nthB;

[eseidel, 2014/07/29 15:43:22]

We could wrap these in private accessors and then not care how they're stored,
now or in the future.

[fs, 2014/07/29 17:14:32]

Done.

     return true;
 }
 
 // a helper function for checking nth-arguments
 bool CSSSelector::RareData::matchNth(int count)
 {
-    if (!m_a)
-        return count == m_b;
-    else if (m_a > 0) {
-        if (count < m_b)
+    if (!m_bits.m_nth.m_a)

[eseidel, 2014/07/29 15:43:22]

nthAValue() might be shorter?

[fs, 2014/07/29 17:14:32]

Yepp, and looks nicer as a bonus. Added.

+        return count == m_bits.m_nth.m_b;
+    if (m_bits.m_nth.m_a > 0) {
+        if (count < m_bits.m_nth.m_b)
             return false;
-        return (count - m_b) % m_a == 0;
-    } else {
-        if (count > m_b)
-            return false;
-        return (m_b - count) % (-m_a) == 0;
+        return (count - m_bits.m_nth.m_b) % m_bits.m_nth.m_a == 0;
     }
+    if (count > m_bits.m_nth.m_b)
+        return false;
+    return (m_bits.m_nth.m_b - count) % (-m_bits.m_nth.m_a) == 0;
 }
 
 } // namespace blink