Use StringView for startsWith and endsWith.

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 689 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();
 }
 
-static inline bool localeIdMatchesLang(const AtomicString& localeId, const char* lang)
+static inline bool localeIdMatchesLang(const AtomicString& localeId, const StringView& lang)
 {
-    size_t langLength = strlen(lang);
-    RELEASE_ASSERT(langLength >= 2 && langLength <= 3);
-    if (!localeId.impl() || !localeId.impl()->startsWithIgnoringCase(lang, langLength))
+    RELEASE_ASSERT(lang.length() >= 2 && lang.length() <= 3);
+    if (!localeId.impl() || !localeId.impl()->startsWithIgnoringCase(lang))
         return false;
-    if (localeId.impl()->length() == langLength)
+    if (localeId.impl()->length() == lang.length())
         return true;
-    const UChar maybeDelimiter = (*localeId.impl())[langLength];
+    const UChar maybeDelimiter = (*localeId.impl())[lang.length()];
     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)
 {
     UChar* data16;
     size_t targetLength = length;
     RefPtr<StringImpl> output = StringImpl::createUninitialized(length, data16);
@@ skipping 762 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 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* prefixString, unsigned prefixLength) const
+bool StringImpl::startsWith(const StringView& prefix) const
 {
-    ASSERT(prefixLength);
-    if (prefixLength > length())
+    if (prefix.length() > length())
         return false;
-    return equalSubstring(this, 0, reinterpret_cast<const LChar*>(prefixString), prefixLength);
+    if (is8Bit()) {
+        if (prefix.is8Bit())
+            return equal(characters8(), prefix.characters8(), prefix.length());
+        return equal(characters8(), prefix.characters16(), prefix.length());
+    }
+    if (prefix.is8Bit())
+        return equal(characters16(), prefix.characters8(), prefix.length());
+    return equal(characters16(), prefix.characters16(), prefix.length());
 }
 
-ALWAYS_INLINE static bool equalSubstring(const StringImpl* stringImpl, unsigned startOffset, const StringImpl* matchString)
+bool StringImpl::startsWithIgnoringCase(const StringView& prefix) const
 {
-    ASSERT(stringImpl);
-    ASSERT(matchString);
-    ASSERT(matchString->length() <= stringImpl->length());
-    ASSERT(startOffset + matchString->length() <= stringImpl->length());
-
-    unsigned matchLength = matchString->length();
-    if (matchString->is8Bit())
-        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);
+    if (prefix.length() > length())
+        return false;
+    if (is8Bit()) {
+        if (prefix.is8Bit())
+            return equalIgnoringCase(characters8(), prefix.characters8(), prefix.length());
+        return equalIgnoringCase(characters8(), prefix.characters16(), prefix.length());
+    }
+    if (prefix.is8Bit())
+        return equalIgnoringCase(characters16(), prefix.characters8(), prefix.length());
+    return equalIgnoringCase(characters16(), prefix.characters16(), prefix.length());
 }
 
-bool StringImpl::startsWith(const StringImpl* prefix) const
+bool StringImpl::startsWithIgnoringASCIICase(const StringView& prefix) const
 {
-    ASSERT(prefix);
-    if (prefix->length() > length())
+    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 (matchString->is8Bit())
-        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 (matchString->is8Bit())
-        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);
+    if (is8Bit()) {
+        if (prefix.is8Bit())
+            return equalIgnoringASCIICase(characters8(), prefix.characters8(), prefix.length());
+        return equalIgnoringASCIICase(characters8(), prefix.characters16(), prefix.length());
+    }
+    if (prefix.is8Bit())
+        return equalIgnoringASCIICase(characters16(), prefix.characters8(), prefix.length());
+    return equalIgnoringASCIICase(characters16(), prefix.characters16(), prefix.length());
 }
 
 bool StringImpl::endsWith(UChar character) const
 {
     return m_length && (*this)[m_length - 1] == character;
 }
 
-bool StringImpl::endsWith(const char* suffixString, unsigned suffixLength) const
+bool StringImpl::endsWith(const StringView& suffix) const
 {
-    ASSERT(suffixLength);
-    if (suffixLength > length())
+    if (suffix.length() > length())
         return false;
-    return equalSubstring(this, length() - suffixLength, reinterpret_cast<const LChar*>(suffixString), suffixLength);
+    unsigned startOffset = length() - suffix.length();
+    if (is8Bit()) {
+        if (suffix.is8Bit())
+            return equal(characters8() + startOffset, suffix.characters8(), suffix.length());
+        return equal(characters8() + startOffset, suffix.characters16(), suffix.length());
+    }
+    if (suffix.is8Bit())
+        return equal(characters16() + startOffset, suffix.characters8(), suffix.length());
+    return equal(characters16() + startOffset, suffix.characters16(), suffix.length());
 }
 
-bool StringImpl::endsWith(const StringImpl* suffix) const
+bool StringImpl::endsWithIgnoringCase(const StringView& suffix) const
 {
-    ASSERT(suffix);
-    unsigned suffixLength = suffix->length();
-    if (suffixLength > length())
+    if (suffix.length() > length())
         return false;
-    return equalSubstring(this, length() - suffixLength, suffix);
+    unsigned startOffset = length() - suffix.length();
+    if (is8Bit()) {
+        if (suffix.is8Bit())
+            return equalIgnoringCase(characters8() + startOffset, suffix.characters8(), suffix.length());
+        return equalIgnoringCase(characters8() + startOffset, suffix.characters16(), suffix.length());
+    }
+    if (suffix.is8Bit())
+        return equalIgnoringCase(characters16() + startOffset, suffix.characters8(), suffix.length());
+    return equalIgnoringCase(characters16() + startOffset, suffix.characters16(), suffix.length());
 }
 
-bool StringImpl::endsWithIgnoringCase(const char* suffixString, unsigned suffixLength) const
+bool StringImpl::endsWithIgnoringASCIICase(const StringView& suffix) const
 {
-    ASSERT(suffixLength);
-    if (suffixLength > length())
+    if (suffix.length() > 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);
+    unsigned startOffset = length() - suffix.length();
+    if (is8Bit()) {
+        if (suffix.is8Bit())
+            return equalIgnoringASCIICase(characters8() + startOffset, suffix.characters8(), suffix.length());
+        return equalIgnoringASCIICase(characters8() + startOffset, suffix.characters16(), suffix.length());
+    }
+    if (suffix.is8Bit())
+        return equalIgnoringASCIICase(characters16() + startOffset, suffix.characters8(), suffix.length());
+    return equalIgnoringASCIICase(characters16() + startOffset, suffix.characters16(), suffix.length());
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar oldC, UChar newC)
 {
     if (oldC == newC)
         return this;
 
     if (find(oldC) == kNotFound)
         return this;
 
@@ skipping 554 matching lines @@
 
 bool equalIgnoringNullity(StringImpl* a, StringImpl* b)
 {
     if (!a && b && !b->length())
         return true;
     if (!b && a && !a->length())
         return true;
     return equal(a, b);
 }
 
-bool equalIgnoringASCIICase(const StringImpl* a, const StringImpl* b)
-{
-    if (!a || !b)
-        return !a == !b;
-    unsigned length = b->length();
-    if (a->length() != length)
-        return false;
-    if (a->is8Bit()) {
-        if (b->is8Bit())
-            return equalIgnoringASCIICase(a->characters8(), b->characters8(), length);
-        return equalIgnoringASCIICase(a->characters8(), b->characters16(), length);
-    }
-    if (b->is8Bit())
-        return equalIgnoringASCIICase(a->characters16(), b->characters8(), length);
-    return equalIgnoringASCIICase(a->characters16(), b->characters16(), length);
-}
-
-bool equalIgnoringASCIICase(const StringImpl* a, const LChar* b, unsigned length)
-{
-    if (!a || !b)
-        return !a == !b;
-    if (length != a->length())
-        return false;
-    return equalSubstringIgnoringASCIICase(a, 0, b, length);
-}
-
 template<typename CharacterType1, typename CharacterType2>
 int codePointCompareIgnoringASCIICase(unsigned l1, unsigned l2, const CharacterType1* c1, const CharacterType2* c2)
 {
     const unsigned lmin = l1 < l2 ? l1 : l2;
     unsigned pos = 0;
     while (pos < lmin && toASCIILower(*c1) == toASCIILower(*c2)) {
         ++c1;
         ++c2;
         ++pos;
     }
@@ skipping 42 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