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*);

[haraken, 2016/08/04 09:05:28]

Add explicit.

[esprehn, 2016/08/04 18:30:08]

It's implicit on purpose, otherwise doing

StringImpl* string;
if (equalIgnoringCase("example", string))

won't work.

+    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 a non-null StringImpl, avoids the null check.
     StringView(StringImpl& impl)
         : m_impl(&impl)
         , m_bytes(impl.bytes())
         , m_length(impl.length()) {}
     StringView(StringImpl&, unsigned offset);
     StringView(StringImpl&, unsigned offset, unsigned length);
 
     // From an String, implemented in String.h
@@ skipping 71 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 StringView::StringView(StringImpl& impl, unsigned offset)
 {
     set(impl, offset, impl.length() - offset);
 }
 
 inline StringView::StringView(StringImpl& impl, unsigned offset, unsigned length)
 {
     set(impl, offset, length);
 }
 
 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