Expand WTF::StringView's API to be more like StringPiece.

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_StringView_h
 #define WTF_StringView_h
 
 #include "wtf/Allocator.h"
-#include "wtf/text/StringImpl.h"
+#include "wtf/text/Unicode.h"
+#include <cstring>
 
 namespace WTF {
 
+class AtomicString;
+class String;
+class StringImpl;
+
 class WTF_EXPORT StringView {
-    DISALLOW_NEW();
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
-    StringView()
-        : m_offset(0)
-        , m_length(0)
-    {
-    }
+    // Null string.
+    StringView() { clear(); }
 
-    explicit StringView(PassRefPtr<StringImpl> impl)
-        : m_impl(impl)
-        , m_offset(0)
-        , m_length(m_impl->length())
-    {
-    }
+    // From a StringImpl (implemented in StringImpl.h)
+    StringView(StringImpl*);
+    StringView(StringImpl*, unsigned offset);
+    StringView(StringImpl*, unsigned offset, unsigned length);
 
-    StringView(PassRefPtr<StringImpl> impl, unsigned offset, unsigned length)
-        : m_impl(impl)
-        , m_offset(offset)
-        , m_length(length)
-    {
-        ASSERT_WITH_SECURITY_IMPLICATION(offset + length <= m_impl->length());
-    }
+    // From a String (implemented in WTFString.h)
+    StringView(const String&);
+    StringView(const String&, unsigned offset);
+    StringView(const String&, unsigned offset, unsigned length);
 
-    void narrow(unsigned offset, unsigned length)
-    {
-        ASSERT_WITH_SECURITY_IMPLICATION(offset + length <= m_length);
-        m_offset += offset;
-        m_length = length;
-    }
+    // From an AtomicString (implemented in in AtomicString.h)
+    StringView(const AtomicString&);
+    StringView(const AtomicString&, unsigned offset);
+    StringView(const AtomicString&, unsigned offset, unsigned length);
 
+    // From a StringView.
+    StringView(const StringView&, unsigned offset);
+    StringView(const StringView&, unsigned offset, unsigned length);
+
+    // From a literal string or LChar buffer.
+    StringView(const LChar* chars);
+    StringView(const char* chars);
+    StringView(const LChar* chars, unsigned length);
+    StringView(const char* chars, unsigned length);
+
+    // From a UChar buffer.
+    StringView(const UChar* chars);
+    StringView(const UChar* chars, unsigned length);
+
+    bool isNull() const { return !m_data.bytes; }
     bool isEmpty() const { return !m_length; }

[haraken, 2016/05/26 22:27:22]

I'm not sure if we need to distinguish a null StringView from an empty
StringView.

[esprehn, 2016/05/26 22:40:21]

This has the same semantics as String, which are needed to make this a drop in
replacement.

isEmpty() == (isNull() || length() == 0)

See WTFString.h's isNull().

[haraken, 2016/05/26 22:45:24]

Yes, but that's an optimization for WTFString to avoid creating an unnecessary
StringImpl object. StringView doesn't hold a StringImpl object, so I'm not sure
if we need to distinguish isNull() and isEmpty().

[esprehn, 2016/05/26 22:48:40]

We do need to, otherwise code like ScriptRegexp::match can't use StringView
since the web has different behavior for null vs empty.

ex of ScriptRegex:

/^$/.test("") => true
/^$/.test(null) => false

[esprehn, 2016/05/26 22:57:41]

literally ScriptRegex would be:

ScriptRegexp("^$", TextCaseSensitive).match(String("")) => 0
ScriptRegexp("^$", TextCaseSensitive).match(String()) => -1

+
     unsigned length() const { return m_length; }
 
-    bool is8Bit() const { return m_impl->is8Bit(); }
+    bool is8Bit() const { return m_is8Bit; }
+
+    void clear()
+    {
+        m_length = 0;
+        m_is8Bit = true;
+        m_data.bytes = nullptr;
+    }
 
     const LChar* characters8() const
     {
-        if (!m_impl)
-            return 0;
         ASSERT(is8Bit());
-        return m_impl->characters8() + m_offset;
+        return m_data.characters8;
     }
 
     const UChar* characters16() const
     {
-        if (!m_impl)
-            return 0;
         ASSERT(!is8Bit());
-        return m_impl->characters16() + m_offset;
+        return m_data.characters16;
     }
 
-    PassRefPtr<StringImpl> toString() const
-    {
-        if (!m_impl)
-            return m_impl;
-        if (m_impl->is8Bit())
-            return StringImpl::create(characters8(), m_length);
-        return StringImpl::create(characters16(), m_length);
-    }
+    String toString() const;
 
 private:
-    RefPtr<StringImpl> m_impl;
-    unsigned m_offset;
+    // Implemented in StringImpl.h
+    void set(StringImpl&, unsigned offset, unsigned length);
+
+    union DataUnion {
+        const LChar* characters8;
+        const UChar* characters16;
+        const void* bytes;
+    } m_data;
     unsigned m_length;
+    unsigned m_is8Bit : 1;
 };
 
+inline StringView::StringView(const StringView& view, unsigned offset, unsigned length)
+    : m_length(length)
+    , m_is8Bit(view.is8Bit())
+{
+    if (is8Bit())
+        m_data.characters8 = view.characters8() + offset;
+    else
+        m_data.characters16 = view.characters16() + offset;
+}
+
+inline StringView::StringView(const StringView& view, unsigned offset)
+    : StringView(view, offset, view.m_length) {}
+
+inline StringView::StringView(const LChar* chars, unsigned length)
+    : m_length(length)
+    , m_is8Bit(true)
+{
+    SECURITY_DCHECK(!chars || length <= strlen(reinterpret_cast<const char*>(chars)));
+    m_data.characters8 = chars;
+}
+
+inline StringView::StringView(const char* chars, unsigned length)
+    : StringView(reinterpret_cast<const LChar*>(chars), length) {}
+inline StringView::StringView(const LChar* chars)
+    : StringView(chars, chars ? strlen(reinterpret_cast<const char*>(chars)) : 0) {}
+inline StringView::StringView(const char* chars)
+    : StringView(reinterpret_cast<const LChar*>(chars)) {}
+
+// TODO(esprehn): Can't make this an overload of WTF::equal since that makes
+// calls to equal() that pass literal strings ambigious. Figure out if we can

[haraken, 2016/05/26 22:27:22]

ambiguous

+// replace all the callers with equalStringView and then rename it to equal().
+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;
 
 #endif