Add support for case-insensitive attribute value selectors

Source/core/css/CSSSelector.h

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 221 matching lines @@
             BottomRightMarginBox,
             BottomRightCornerMarginBox,
             LeftTopMarginBox,
             LeftMiddleMarginBox,
             LeftBottomMarginBox,
             RightTopMarginBox,
             RightMiddleMarginBox,
             RightBottomMarginBox,
         };
 
+        enum AttributeFlags {
+            NoAttributeFlags,
+            CaseInsensitive,
+        };
+
         PseudoType pseudoType() const
         {
             if (m_pseudoType == PseudoNotParsed)
                 extractPseudoType();
             return static_cast<PseudoType>(m_pseudoType);
         }
 
         static PseudoType parsePseudoType(const AtomicString&);
         static PseudoId pseudoId(PseudoType);
 
         // Selectors are kept in an array by CSSSelectorList. The next component of the selector is
         // the next item in the array.
         const CSSSelector* tagHistory() const { return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1); }
 
         const QualifiedName& tagQName() const;
         const AtomicString& value() const;
 
         // WARNING: Use of QualifiedName by attribute() is a lie.
         // attribute() will return a QualifiedName with prefix and namespaceURI
         // set to starAtom to mean "matches any namespace". Be very careful
         // how you use the returned QualifiedName.
         // http://www.w3.org/TR/css3-selectors/#attrnmsp
         const QualifiedName& attribute() const;
+        AttributeFlags attributeFlags() const;
         // 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; }
 
 #ifndef NDEBUG
         void show() const;
         void show(int indent) const;
 #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();
 
         bool parseNth() const;
         bool matchNth(int count) const;
 
         bool matchesPseudoElement() const;
         bool isUnknownPseudoElement() const;
         bool isCustomPseudoElement() const;
@@ skipping 54 matching lines @@
         CSSSelector& operator=(const CSSSelector&);
 
         struct RareData : public RefCounted<RareData> {
             static PassRefPtr<RareData> create(const AtomicString& value) { return adoptRef(new RareData(value)); }
             ~RareData();
 
             bool parseNth();
             bool matchNth(int count);
 
             AtomicString m_value;
-            int m_a; // Used for :nth-*
-            int m_b; // Used for :nth-*
+            union Bits {

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

I'm confused by these.  It looks like this is a big object, but I thoguht that
we had a ton of CSSSelector objects, so I would expect them to be size
sensitive, yet we haven't had a union before this one.

this feels like a half-hearte attempt to save space in this object, when we
probably could be more agressive. Can m_attribute and m_argument and m_value all
be used at the same time?  can m_selectorList?  Just confused that we are only
introducing a union now.  Feels like either we should continue to avoid the
union or unionize more of these attributes (in a separate patch).

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

The union is "reaction" to comments in
https://codereview.chromium.org/252683011/ (the origin of this code). I don't
really have any data on with the frequencies of the different selector-types, so
this was mostly intended as an illustration of how the new field could be added
without affecting the "status quo" (memory-wise). I can revert the union-bit
again if requested (the fact that there's DataUnion in outer-class suggests to
me that this indeed rare data.)

(IIRC, the "groups" are (excluding the new field):

m_value+m_attribute
m_value+m_selectorList
m_value+m_argument+m_nth{A,B})

+                Bits() : m_nth() { }

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

This doesn't do anything.

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

It initializes m_nth to zeros.

+                struct {
+                    int m_a; // Used for :nth-*
+                    int m_b; // Used for :nth-*
+                } m_nth;
+                unsigned m_attributeFlags; // used for attribute selector (with value)
+            } m_bits;
             QualifiedName m_attribute; // used for attribute selector
             AtomicString m_argument; // Used for :contains, :lang, :nth-*
             OwnPtr<CSSSelectorList> m_selectorList; // Used for :-webkit-any and :not
 
         private:
             RareData(const AtomicString& value);
         };
         void createRareData();
 
         union DataUnion {
             DataUnion() : m_value(0) { }
             StringImpl* m_value;
             QualifiedName::QualifiedNameImpl* m_tagQName;
             RareData* m_rareData;
         } m_data;
     };
 
 inline const QualifiedName& CSSSelector::attribute() const
 {
     ASSERT(isAttributeSelector());
     ASSERT(m_hasRareData);
     return m_data.m_rareData->m_attribute;
 }
 
+inline CSSSelector::AttributeFlags CSSSelector::attributeFlags() const
+{
+    ASSERT(isAttributeSelector());
+    ASSERT(m_hasRareData);
+    return static_cast<AttributeFlags>(m_data.m_rareData->m_bits.m_attributeFlags);
+}
+
 inline bool CSSSelector::matchesPseudoElement() const
 {
     if (m_pseudoType == PseudoUnknown)
         extractPseudoType();
     return m_match == PseudoElement;
 }
 
 inline bool CSSSelector::isUnknownPseudoElement() const
 {
     return m_match == PseudoElement && m_pseudoType == PseudoUnknown;
@@ skipping 133 matching lines @@
     if (m_hasRareData)
         return m_data.m_rareData->m_value;
     // AtomicString is really just a StringImpl* so the cast below is safe.
     // FIXME: Perhaps call sites could be changed to accept StringImpl?
     return *reinterpret_cast<const AtomicString*>(&m_data.m_value);
 }
 
 } // namespace blink
 
 #endif // CSSSelector_h