Restore TextCaseSensitivity argument to literal {start,end}sWith

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 633 matching lines @@
     int32_t realLength = Unicode::toUpper(data16, length, source16, m_length, &error);
     if (!error && realLength == length)
         return newImpl;
     newImpl = createUninitialized(realLength, data16);
     Unicode::toUpper(data16, realLength, source16, m_length, &error);
     if (error)
         return this;
     return newImpl.release();
 }
 
-ALWAYS_INLINE static bool startsWithIgnoringCase(const StringImpl* stringImpl, const LChar* prefix, unsigned prefixLength)
-{
-    ASSERT(stringImpl);
-    if (prefixLength > stringImpl->length())
-        return false;
-    if (stringImpl->is8Bit())
-        return equalIgnoringCase(stringImpl->characters8(), prefix, prefixLength);
-    return equalIgnoringCase(stringImpl->characters16(), prefix, prefixLength);
-}
-
 static inline bool localeIdMatchesLang(const AtomicString& localeId, const char* lang)
 {
     size_t langLength = strlen(lang);
     RELEASE_ASSERT(langLength >= 2 && langLength <= 3);
-    if (!localeId.impl() || !startsWithIgnoringCase(localeId.impl(), reinterpret_cast<const LChar*>(lang), langLength))
+    if (!localeId.impl() || !localeId.impl()->startsWithIgnoringCase(lang, langLength))
         return false;
     if (localeId.impl()->length() == langLength)
         return true;
     const UChar maybeDelimiter = (*localeId.impl())[langLength];
     return maybeDelimiter == '-' || maybeDelimiter == '_' || maybeDelimiter == '@';
 }
 
 typedef int32_t (*icuCaseConverter)(UChar*, int32_t, const UChar*, int32_t, const char*, UErrorCode*);
 
 static PassRefPtr<StringImpl> caseConvert(const UChar* source16, size_t length, icuCaseConverter converter, const char* locale, StringImpl* originalString)
@@ skipping 784 matching lines @@
             return reverseFindInner(characters8(), matchString->characters8(), index, ourLength, matchLength);
         return reverseFindInner(characters8(), matchString->characters16(), index, ourLength, matchLength);
     }
 
     if (matchString->is8Bit())
         return reverseFindInner(characters16(), matchString->characters8(), index, ourLength, matchLength);
 
     return reverseFindInner(characters16(), matchString->characters16(), index, ourLength, matchLength);
 }
 
-ALWAYS_INLINE static bool equalInner(const StringImpl* stringImpl, unsigned startOffset, const LChar* matchString, unsigned matchLength)
+ALWAYS_INLINE static bool equalSubstring(const StringImpl* stringImpl, unsigned startOffset, const LChar* matchString, unsigned matchLength)
 {
     ASSERT(stringImpl);
     ASSERT(matchLength <= stringImpl->length());
     ASSERT(startOffset + matchLength <= stringImpl->length());
 
     if (stringImpl->is8Bit())
         return equal(stringImpl->characters8() + startOffset, matchString, matchLength);
     return equal(stringImpl->characters16() + startOffset, matchString, matchLength);
 }
 
 bool StringImpl::startsWith(UChar character) const
 {
     return m_length && (*this)[0] == character;
 }
 
-bool StringImpl::startsWith(const char* matchString, unsigned matchLength) const
+bool StringImpl::startsWith(const char* prefixString, unsigned prefixLength) const
 {
-    ASSERT(matchLength);
-    if (matchLength > length())
+    ASSERT(prefixLength);
+    if (prefixLength > length())
         return false;
-    return equalInner(this, 0, reinterpret_cast<const LChar*>(matchString), matchLength);
+    return equalSubstring(this, 0, reinterpret_cast<const LChar*>(prefixString), prefixLength);
 }
 
 ALWAYS_INLINE static bool equalSubstring(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 equal(start, matchString->characters8(), matchLength);
-        return equal(start, matchString->characters16(), matchLength);
-    }
-    const UChar* start = stringImpl->characters16() + startOffset;
     if (matchString->is8Bit())
-        return equal(start, matchString->characters8(), matchLength);
-    return equal(start, matchString->characters16(), matchLength);
+        return equalSubstring(stringImpl, startOffset, matchString->characters8(), matchLength);
+    if (stringImpl->is8Bit())
+        return equal(stringImpl->characters8() + startOffset, matchString->characters16(), matchLength);
+    return equal(stringImpl->characters16() + startOffset, matchString->characters16(), matchLength);
 }
 
 bool StringImpl::startsWith(const StringImpl* prefix) const
 {
     ASSERT(prefix);
     if (prefix->length() > length())
         return false;
     return equalSubstring(this, 0, prefix);
 }
 
+ALWAYS_INLINE static bool equalSubstringIgnoringCase(const StringImpl* stringImpl, unsigned startOffset, const LChar* matchString, unsigned matchLength)
+{
+    ASSERT(stringImpl);
+    ASSERT(matchLength <= stringImpl->length());
+    ASSERT(startOffset + matchLength <= stringImpl->length());
+
+    if (stringImpl->is8Bit())
+        return equalIgnoringCase(stringImpl->characters8() + startOffset, matchString, matchLength);
+    return equalIgnoringCase(stringImpl->characters16() + startOffset, matchString, matchLength);
+}
+
+bool StringImpl::startsWithIgnoringCase(const char* prefixString, unsigned prefixLength) const
+{
+    ASSERT(prefixLength);
+    if (prefixLength > length())
+        return false;
+    return equalSubstringIgnoringCase(this, 0, reinterpret_cast<const LChar*>(prefixString), prefixLength);
+}
+
 ALWAYS_INLINE static bool equalSubstringIgnoringCase(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 equalIgnoringCase(start, matchString->characters8(), matchLength);
-        return equalIgnoringCase(start, matchString->characters16(), matchLength);
-    }
-    const UChar* start = stringImpl->characters16() + startOffset;
     if (matchString->is8Bit())
-        return equalIgnoringCase(start, matchString->characters8(), matchLength);
-    return equalIgnoringCase(start, matchString->characters16(), matchLength);
+        return equalSubstringIgnoringCase(stringImpl, startOffset, matchString->characters8(), matchLength);
+    if (stringImpl->is8Bit())
+        return equalIgnoringCase(stringImpl->characters8() + startOffset, matchString->characters16(), matchLength);
+    return equalIgnoringCase(stringImpl->characters16() + startOffset, matchString->characters16(), matchLength);
 }
 
 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 LChar* matchString, unsigned matchLength)
+{
+    ASSERT(stringImpl);
+    ASSERT(matchLength <= stringImpl->length());
+    ASSERT(startOffset + matchLength <= stringImpl->length());
+
+    if (stringImpl->is8Bit())
+        return equalIgnoringASCIICase(stringImpl->characters8() + startOffset, matchString, matchLength);
+    return equalIgnoringASCIICase(stringImpl->characters16() + startOffset, matchString, matchLength);
+}
+
+bool StringImpl::startsWithIgnoringASCIICase(const char* prefixString, unsigned prefixLength) const
+{
+    ASSERT(prefixLength);
+    if (prefixLength > length())
+        return false;
+    return equalSubstringIgnoringASCIICase(this, 0, reinterpret_cast<const LChar*>(prefixString), prefixLength);
+}
+
 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);
+        return equalSubstringIgnoringASCIICase(stringImpl, startOffset, matchString->characters8(), matchLength);
+    if (stringImpl->is8Bit())
+        return equalIgnoringASCIICase(stringImpl->characters8() + startOffset, matchString->characters16(), matchLength);
+    return equalIgnoringASCIICase(stringImpl->characters16() + startOffset, 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
+bool StringImpl::endsWith(const char* suffixString, unsigned suffixLength) const
 {
-    ASSERT(matchLength);
-    if (matchLength > length())
+    ASSERT(suffixLength);
+    if (suffixLength > length())
         return false;
-    return equalInner(this, length() - matchLength, reinterpret_cast<const LChar*>(matchString), matchLength);
+    return equalSubstring(this, length() - suffixLength, reinterpret_cast<const LChar*>(suffixString), suffixLength);
 }
 
 bool StringImpl::endsWith(const StringImpl* suffix) const
 {
     ASSERT(suffix);
     unsigned suffixLength = suffix->length();
     if (suffixLength > length())
         return false;
     return equalSubstring(this, length() - suffixLength, suffix);
 }
 
+bool StringImpl::endsWithIgnoringCase(const char* suffixString, unsigned suffixLength) const
+{
+    ASSERT(suffixLength);
+    if (suffixLength > length())
+        return false;
+    return equalSubstringIgnoringCase(this, length() - suffixLength, reinterpret_cast<const LChar*>(suffixString), suffixLength);
+}
+
 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 char* suffixString, unsigned suffixLength) const
+{
+    ASSERT(suffixLength);
+    if (suffixLength > length())
+        return false;
+    return equalSubstringIgnoringASCIICase(this, length() - suffixLength, reinterpret_cast<const LChar*>(suffixString), suffixLength);
+}
+
 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)
@@ skipping 587 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