Add support for case-insensitive attribute value selectors

Source/core/css/CSSSelector.h

Index: Source/core/css/CSSSelector.h
diff --git a/Source/core/css/CSSSelector.h b/Source/core/css/CSSSelector.h
index d9c9933b5eb282626bcf6e84a532f724c6d6ede3..36892a43ec0aa926e47cd104c21c7b2ba5f910b8 100644
--- a/Source/core/css/CSSSelector.h
+++ b/Source/core/css/CSSSelector.h
@@ -237,6 +237,11 @@ namespace WebCore {
             RightBottomMarginBox,
         };
 
+        enum AttributeFlags {
+            NoAttributeFlags,
+            CaseInsensitive,
+        };
+
         PseudoType pseudoType() const
         {
             if (m_pseudoType == PseudoNotParsed)
@@ -260,6 +265,7 @@ namespace WebCore {
         // how you use the returned QualifiedName.
         // http://www.w3.org/TR/css3-selectors/#attrnmsp
         const QualifiedName& attribute() const;
+        unsigned attributeFlags() const;

[eseidel, 2014/05/07 18:12:58]

Can't this return the enum?  Normally we store enums as unsigned (bitfields) but
cast them to/from their enum type in getters/setters to allow the rest of the
code to use the compiler's type-safety.

[fs, 2014/06/12 16:42:31]

Sure (done in [1]). It doesn't really add much in terms of type-safety though
(all uses as of now imply widening conversions). Having a flag-field with a
single flag might be a bit overkill though =)

         // Returns the argument of a parameterized selector. For example, nth-child(2) would have an argument of 2.
         const AtomicString& argument() const { return m_hasRareData ? m_data.m_rareData->m_argument : nullAtom; }
         const CSSSelectorList* selectorList() const { return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : 0; }
@@ -270,7 +276,7 @@ namespace WebCore {
 #endif
 
         void setValue(const AtomicString&);
-        void setAttribute(const QualifiedName&);
+        void setAttribute(const QualifiedName&, unsigned flags);
         void setArgument(const AtomicString&);
         void setSelectorList(PassOwnPtr<CSSSelectorList>);
         void setMatchUserAgentOnly();
@@ -337,6 +343,7 @@ namespace WebCore {
             int m_a; // Used for :nth-*
             int m_b; // Used for :nth-*
             QualifiedName m_attribute; // used for attribute selector
+            unsigned m_attributeFlags; // used for attribute selector (with value)

[eseidel, 2014/05/29 00:25:01]

I think we have a ton of CSSSelector objects... I worry this could be bad for
memory?  Ojan would know.

[apavlov, 2014/06/11 12:26:19]

This is RareData. Consequently, it will be found in a small fraction of all
CSSSelectors...

[fs, 2014/06/12 16:42:31]

Yes, hopefully they are indeed "rare". Disregarding that though there's (at
least) two ways to pack this differently:

1) Move the field to the bitfield in CSSSelector (it's only 1 bit right now, and
there seems to be 10 bits left there).
2) Make a union of this and m_a/m_b.

Both of those will cause some "collateral damage" though
(renaming/initializer-lists/etc.)

Any preference there? ((2) sketched out in [1])

             AtomicString m_argument; // Used for :contains, :lang, :nth-*
             OwnPtr<CSSSelectorList> m_selectorList; // Used for :-webkit-any and :not
 
@@ -360,6 +367,13 @@ inline const QualifiedName& CSSSelector::attribute() const
     return m_data.m_rareData->m_attribute;
 }
 
+inline unsigned CSSSelector::attributeFlags() const
+{
+    ASSERT(isAttributeSelector());
+    ASSERT(m_hasRareData);
+    return m_data.m_rareData->m_attributeFlags;
+}
+
 inline bool CSSSelector::matchesPseudoElement() const
 {
     if (m_pseudoType == PseudoUnknown)