Use ASCII case-insensitive matching for attribute selectors

third_party/WebKit/Source/wtf/text/StringImpl.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * 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
@@ skipping 1320 matching lines @@
             return findIgnoringCaseInner(characters8() + index, matchString->characters8(), index, searchLength, matchLength);
         return findIgnoringCaseInner(characters8() + index, matchString->characters16(), index, searchLength, matchLength);
     }
 
     if (matchString->is8Bit())
         return findIgnoringCaseInner(characters16() + index, matchString->characters8(), index, searchLength, matchLength);
 
     return findIgnoringCaseInner(characters16() + index, matchString->characters16(), index, searchLength, matchLength);
 }
 
+template <typename SearchCharacterType, typename MatchCharacterType>
+ALWAYS_INLINE static size_t findIgnoringASCIICaseInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned searchLength, unsigned matchLength)
+{
+    // delta is the number of additional times to test; delta == 0 means test only once.
+    unsigned delta = searchLength - matchLength;
+
+    unsigned i = 0;
+    // keep looping until we match
+    while (!equalIgnoringASCIICase(searchCharacters + i, matchCharacters, matchLength)) {
+        if (i == delta)
+            return kNotFound;
+        ++i;
+    }
+    return index + i;
+}
+
+size_t StringImpl::findIgnoringASCIICase(StringImpl* matchString, unsigned index)
+{
+    // Check for null or empty string to match against
+    if (!matchString)
+        return kNotFound;
+    unsigned matchLength = matchString->length();
+    if (!matchLength)
+        return min(index, length());
+
+    // Check index & matchLength are in range.
+    if (index > length())
+        return kNotFound;
+    unsigned searchLength = length() - index;
+    if (matchLength > searchLength)
+        return kNotFound;
+
+    if (is8Bit()) {
+        const LChar* searchStart = characters8() + index;
+        if (matchString->is8Bit())
+            return findIgnoringASCIICaseInner(searchStart, matchString->characters8(), index, searchLength, matchLength);
+        return findIgnoringASCIICaseInner(searchStart, matchString->characters16(), index, searchLength, matchLength);
+    }
+
+    const UChar* searchStart = characters16() + index;
+    if (matchString->is8Bit())
+        return findIgnoringASCIICaseInner(searchStart, matchString->characters8(), index, searchLength, matchLength);
+    return findIgnoringASCIICaseInner(searchStart, matchString->characters16(), index, searchLength, matchLength);
+}
+
 size_t StringImpl::findNextLineStart(unsigned index)
 {
     if (is8Bit())
         return WTF::findNextLineStart(characters8(), m_length, index);
     return WTF::findNextLineStart(characters16(), m_length, index);
 }
 
 size_t StringImpl::count(LChar c) const
 {
     int count = 0;
@@ skipping 147 matching lines @@
 }
 
 bool StringImpl::startsWithIgnoringCase(const StringImpl* prefix) const
 {
     ASSERT(prefix);
     if (prefix->length() > length())
         return false;
     return equalSubstringIgnoringCase(this, 0, prefix);
 }
 
+ALWAYS_INLINE static bool equalSubstringIgnoringASCIICase(const StringImpl* stringImpl, unsigned startOffset, const StringImpl* matchString)
+{
+    ASSERT(stringImpl);
+    ASSERT(matchString);
+    ASSERT(matchString->length() <= stringImpl->length());
+    ASSERT(startOffset + matchString->length() <= stringImpl->length());
+
+    unsigned matchLength = matchString->length();
+    if (stringImpl->is8Bit()) {
+        const LChar* start = stringImpl->characters8() + startOffset;
+        if (matchString->is8Bit())
+            return equalIgnoringASCIICase(start, matchString->characters8(), matchLength);
+        return equalIgnoringASCIICase(start, matchString->characters16(), matchLength);
+    }
+    const UChar* start = stringImpl->characters16() + startOffset;
+    if (matchString->is8Bit())
+        return equalIgnoringASCIICase(start, matchString->characters8(), matchLength);
+    return equalIgnoringASCIICase(start, matchString->characters16(), matchLength);
+}
+
+bool StringImpl::startsWithIgnoringASCIICase(const StringImpl* prefix) const
+{
+    ASSERT(prefix);
+    if (prefix->length() > length())
+        return false;
+    return equalSubstringIgnoringASCIICase(this, 0, prefix);
+}
+
 bool StringImpl::endsWith(UChar character) const
 {
     return m_length && (*this)[m_length - 1] == character;
 }
 
 bool StringImpl::endsWith(const char* matchString, unsigned matchLength) const
 {
     ASSERT(matchLength);
     if (matchLength > length())
         return false;
@@ skipping 11 matching lines @@
 
 bool StringImpl::endsWithIgnoringCase(const StringImpl* suffix) const
 {
     ASSERT(suffix);
     unsigned suffixLength = suffix->length();
     if (suffixLength > length())
         return false;
     return equalSubstringIgnoringCase(this, length() - suffixLength, suffix);
 }
 
+bool StringImpl::endsWithIgnoringASCIICase(const StringImpl* suffix) const
+{
+    ASSERT(suffix);
+    unsigned suffixLength = suffix->length();
+    if (suffixLength > length())
+        return false;
+    return equalSubstringIgnoringASCIICase(this, length() - suffixLength, suffix);
+}
+
 PassRefPtr<StringImpl> StringImpl::replace(UChar oldC, UChar newC)
 {
     if (oldC == newC)
         return this;
 
     if (find(oldC) == kNotFound)
         return this;
 
     unsigned i;
     if (is8Bit()) {
@@ skipping 578 matching lines @@
         } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
             // TODO(rob.buis) implement upper-casing rules for lt
             // like in StringImpl::upper(locale).
         }
     }
 
     return toUpper(c);
 }
 
 } // namespace WTF