Use StringView for equalIgnoringCase.

third_party/WebKit/Source/wtf/text/StringView.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WTF_StringView_h
 #define WTF_StringView_h
 
 #include "wtf/Allocator.h"
 #include "wtf/GetPtr.h"
 #if DCHECK_IS_ON()
@@ skipping 21 matching lines @@
 public:
     // Null string.
     StringView() { clear(); }
 
     // From a StringView:
     StringView(const StringView&, unsigned offset, unsigned length);
     StringView(const StringView& view, unsigned offset)
         : StringView(view, offset, view.m_length - offset) {}
 
     // From a StringImpl:
-    StringView(StringImpl*);
-    StringView(StringImpl*, unsigned offset);
-    StringView(StringImpl*, unsigned offset, unsigned length);
+    StringView(const StringImpl*);

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

const StringImpl* is kind of silly since they're immutable, at one point people
tried using it to signal that the ref count won't be modified, but the
RefCounted's ref() and deref() are actually const since a ref count is logically
const and RefPtr<const Foo> is supposed to work (base does this too) so it
doesn't really matter anymore.

Some callers of equalsIgnoringCase have a const StringImpl, so we add it here
too which matches the old signature of equalIgnoringCase.

+    StringView(const StringImpl*, unsigned offset);
+    StringView(const StringImpl*, unsigned offset, unsigned length);
+
+    // From a non-null StringImpl.
+    StringView(const StringImpl& impl)
+        : m_impl(const_cast<StringImpl*>(&impl))
+        , m_bytes(impl.bytes())
+        , m_length(impl.length()) {}
 
     // From an String, implemented in String.h
     inline StringView(const String&, unsigned offset, unsigned length);
     inline StringView(const String&, unsigned offset);
     inline StringView(const String&);
 
     // From an AtomicString, implemented in AtomicString.h
     inline StringView(const AtomicString&, unsigned offset, unsigned length);
     inline StringView(const AtomicString&, unsigned offset);
     inline StringView(const AtomicString&);
@@ skipping 63 matching lines @@
         // directly since this == StringView(m_impl).
         if (m_impl->bytes() == bytes() && m_length == m_impl->length())
             return getPtr(m_impl);
         return nullptr;
     }
 
     String toString() const;
     AtomicString toAtomicString() const;
 
 private:
-    void set(StringImpl&, unsigned offset, unsigned length);
+    void set(const StringImpl&, unsigned offset, unsigned length);
 
     // We use the StringImpl to mark for 8bit or 16bit, even for strings where
     // we were constructed from a char pointer. So m_impl->bytes() might have
     // nothing to do with this view's bytes().
 #if DCHECK_IS_ON()
     RefPtr<StringImpl> m_impl;
 #else
     StringImpl* m_impl;
 #endif
     union {
         const LChar* m_characters8;
         const UChar* m_characters16;
         const void* m_bytes;
     };
     unsigned m_length;
 };
 
 inline StringView::StringView(const StringView& view, unsigned offset, unsigned length)
     : m_impl(view.m_impl)
     , m_length(length)
 {
     SECURITY_DCHECK(offset + length <= view.length());
     if (is8Bit())
         m_characters8 = view.characters8() + offset;
     else
         m_characters16 = view.characters16() + offset;
 }
 
-inline StringView::StringView(StringImpl* impl)
+inline StringView::StringView(const StringImpl* impl)
 {
     if (!impl) {
         clear();
         return;
     }
-    m_impl = impl;
+    m_impl = const_cast<StringImpl*>(impl);
     m_length = impl->length();
     m_bytes = impl->bytes();
 }
 
-inline StringView::StringView(StringImpl* impl, unsigned offset)
+inline StringView::StringView(const StringImpl* impl, unsigned offset)
 {
     impl ? set(*impl, offset, impl->length() - offset) : clear();
 }
 
-inline StringView::StringView(StringImpl* impl, unsigned offset, unsigned length)
+inline StringView::StringView(const StringImpl* impl, unsigned offset, unsigned length)
 {
     impl ? set(*impl, offset, length) : clear();
 }
 
 inline void StringView::clear()
 {
     m_length = 0;
     m_bytes = nullptr;
     m_impl = StringImpl::empty(); // mark as 8 bit.
 }
 
-inline void StringView::set(StringImpl& impl, unsigned offset, unsigned length)
+inline void StringView::set(const StringImpl& impl, unsigned offset, unsigned length)
 {
     SECURITY_DCHECK(offset + length <= impl.length());
     m_length = length;
-    m_impl = &impl;
+    m_impl = const_cast<StringImpl*>(&impl);
     if (impl.is8Bit())
         m_characters8 = impl.characters8() + offset;
     else
         m_characters16 = impl.characters16() + offset;
 }
 
-WTF_EXPORT bool equalIgnoringASCIICase(const StringView& a, const StringView& b);
+WTF_EXPORT bool equalIgnoringCase(const StringView&, const StringView&);
+WTF_EXPORT bool equalIgnoringASCIICase(const StringView&, const StringView&);
+
+WTF_EXPORT bool equalIgnoringCaseAndNullity(const StringView&, const StringView&);
 
 // TODO(esprehn): Can't make this an overload of WTF::equal since that makes
 // calls to equal() that pass literal strings ambiguous. Figure out if we can
 // replace all the callers with equalStringView and then rename it to equal().
 WTF_EXPORT bool equalStringView(const StringView&, const StringView&);
 
 inline bool operator==(const StringView& a, const StringView& b)
 {
     return equalStringView(a, b);
 }
 
 inline bool operator!=(const StringView& a, const StringView& b)
 {
     return !(a == b);
 }
 
 } // namespace WTF
 
 using WTF::StringView;
+using WTF::equalIgnoringASCIICase;
+using WTF::equalIgnoringCase;
+
 
 #endif