Use StringView for equalIgnoringCase.

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

Index: third_party/WebKit/Source/wtf/text/StringImpl.cpp
diff --git a/third_party/WebKit/Source/wtf/text/StringImpl.cpp b/third_party/WebKit/Source/wtf/text/StringImpl.cpp
index a18498fabeb89f6ec9b520273c8a3e23664b55a3..b79ab73bbaccb5188fb7c14b5d64b31a470c5f84 100644
--- a/third_party/WebKit/Source/wtf/text/StringImpl.cpp
+++ b/third_party/WebKit/Source/wtf/text/StringImpl.cpp
@@ -2070,93 +2070,6 @@ bool equalNonNull(const StringImpl* a, const StringImpl* b)
     return stringImplContentEqual(a, b);
 }
 
-bool equalIgnoringCase(const StringImpl* a, const StringImpl* b)
-{
-    if (a == b)
-        return true;
-    if (!a || !b)
-        return false;
-
-    return CaseFoldingHash::equal(a, b);
-}
-
-bool equalIgnoringCase(const StringImpl* a, const LChar* b)
-{
-    if (!a)
-        return !b;
-    if (!b)
-        return !a;
-
-    unsigned length = a->length();
-
-    // Do a faster loop for the case where all the characters are ASCII.
-    UChar ored = 0;
-    bool equal = true;
-    if (a->is8Bit()) {
-        const LChar* as = a->characters8();
-        for (unsigned i = 0; i != length; ++i) {
-            LChar bc = b[i];
-            if (!bc)
-                return false;
-            UChar ac = as[i];
-            ored |= ac;
-            equal = equal && (toASCIILower(ac) == toASCIILower(bc));

[esprehn, 2016/08/04 08:43:06]

We lose this fancy ASCII path and end up doing:

    while (length--) {
        if (StringImpl::latin1CaseFoldTable[*a++] !=
StringImpl::latin1CaseFoldTable[*b++])
            return false;
    }

-        }
-
-        // Do a slower implementation for cases that include non-ASCII characters.
-        if (ored & ~0x7F) {
-            equal = true;
-            for (unsigned i = 0; i != length; ++i)
-                equal = equal && (foldCase(as[i]) == foldCase(b[i]));
-        }
-
-        return equal && !b[length];
-    }
-
-    const UChar* as = a->characters16();
-    for (unsigned i = 0; i != length; ++i) {
-        LChar bc = b[i];
-        if (!bc)
-            return false;
-        UChar ac = as[i];
-        ored |= ac;
-        equal = equal && (toASCIILower(ac) == toASCIILower(bc));
-    }
-
-    // Do a slower implementation for cases that include non-ASCII characters.
-    if (ored & ~0x7F) {
-        equal = true;
-        for (unsigned i = 0; i != length; ++i) {
-            equal = equal && (foldCase(as[i]) == foldCase(b[i]));

[esprehn, 2016/08/04 08:43:06]

We also lose this ASCII fast path and end up doing:

    while (length--) {
        if (foldCase(*a++) != StringImpl::latin1CaseFoldTable[*b++])
            return false;
    }

which is probably slower since we need to call foldCase. If this shows up in
benchmarks we can add this ASCII fast path back to
equalIgnoringCase(const UChar* a, const LChar* b, unsigned length)

but I'd like to just remove it for now since the (UChar*, LChar*) version of
this never had this fast path. The fast path dates to an ancient patch from
2006:
https://chromium.googlesource.com/chromium/src/+/6f022a05a21fc5ed091d7bcb6b81...

but there's nothing cited in it about why darin added all of these fast paths
all over. It's possible calling ICU is slow, but lets find out.

-        }
-    }
-
-    return equal && !b[length];
-}
-
-bool equalIgnoringCaseNonNull(const StringImpl* a, const StringImpl* b)
-{
-    ASSERT(a && b);
-    if (a == b)
-        return true;
-
-    unsigned length = a->length();
-    if (length != b->length())
-        return false;
-
-    if (a->is8Bit()) {
-        if (b->is8Bit())
-            return equalIgnoringCase(a->characters8(), b->characters8(), length);
-
-        return equalIgnoringCase(b->characters16(), a->characters8(), length);
-    }
-
-    if (b->is8Bit())
-        return equalIgnoringCase(a->characters16(), b->characters8(), length);
-
-    return equalIgnoringCase(a->characters16(), b->characters16(), length);
-}
-
 bool equalIgnoringNullity(StringImpl* a, StringImpl* b)
 {
     if (!a && b && !b->length())