Use StringView for String::append and ::insert.

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 58 matching lines @@
 String::String(const LChar* characters)
     : m_impl(characters ? StringImpl::create(characters) : nullptr)
 {
 }
 
 String::String(const char* characters)
     : m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters)) : nullptr)
 {
 }
 
-void String::append(const String& string)
+void String::append(const StringView& string)
 {
     if (string.isEmpty())
         return;
     if (!m_impl) {
-        m_impl = string.m_impl;
+        m_impl = string.toString().releaseImpl();
         return;
     }
 
     // FIXME: This is extremely inefficient. So much so that we might want to
     // take this out of String's API. We can make it better by optimizing the
     // case where exactly one String is pointing at this StringImpl, but even
     // then it's going to require a call into the allocator every single time.
 
-    if (m_impl->is8Bit() && string.m_impl->is8Bit()) {
+    if (m_impl->is8Bit() && string.is8Bit()) {
         LChar* data;
         RELEASE_ASSERT(string.length() <= std::numeric_limits<unsigned>::max() - m_impl->length());
         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + string.length(), data);
         memcpy(data, m_impl->characters8(), m_impl->length() * sizeof(LChar));
         memcpy(data + m_impl->length(), string.characters8(), string.length() * sizeof(LChar));
         m_impl = newImpl.release();
         return;
     }
 
     UChar* data;
     RELEASE_ASSERT(string.length() <= std::numeric_limits<unsigned>::max() - m_impl->length());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + string.length(), data);
 
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, m_impl->characters8(), m_impl->length());
     else
         StringImpl::copyChars(data, m_impl->characters16(), m_impl->length());
 
-    if (string.impl()->is8Bit())
-        StringImpl::copyChars(data + m_impl->length(), string.impl()->characters8(), string.impl()->length());
+    if (string.is8Bit())
+        StringImpl::copyChars(data + m_impl->length(), string.characters8(), string.length());
     else
-        StringImpl::copyChars(data + m_impl->length(), string.impl()->characters16(), string.impl()->length());
+        StringImpl::copyChars(data + m_impl->length(), string.characters16(), string.length());
 
     m_impl = newImpl.release();
 }
 
 template <typename CharacterType>
 inline void String::appendInternal(CharacterType c)
 {
     // FIXME: This is extremely inefficient. So much so that we might want to
     // take this out of String's API. We can make it better by optimizing the
     // case where exactly one String is pointing at this StringImpl, but even
@@ skipping 28 matching lines @@
 int codePointCompare(const String& a, const String& b)
 {
     return codePointCompare(a.impl(), b.impl());
 }
 
 int codePointCompareIgnoringASCIICase(const String& a, const char* b)
 {
     return codePointCompareIgnoringASCIICase(a.impl(), reinterpret_cast<const LChar*>(b));
 }
 
-void String::insert(const String& string, unsigned position)
-{
-    if (string.isEmpty()) {
-        if (string.isNull())
-            return;
-        if (isNull())
-            m_impl = string.impl();
-        return;
-    }
-
-    if (string.is8Bit())
-        insert(string.impl()->characters8(), string.length(), position);
-    else
-        insert(string.impl()->characters16(), string.length(), position);
-}
-
-void String::append(const LChar* charactersToAppend, unsigned lengthToAppend)
-{
-    if (!m_impl) {
-        if (!charactersToAppend)
-            return;
-        m_impl = StringImpl::create(charactersToAppend, lengthToAppend);
-        return;
-    }
-
-    if (!lengthToAppend)
-        return;
-
-    ASSERT(charactersToAppend);
-
-    unsigned strLength = m_impl->length();
-
-    if (m_impl->is8Bit()) {
-        RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
-        LChar* data;
-        RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
-        StringImpl::copyChars(data, m_impl->characters8(), strLength);
-        StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
-        m_impl = newImpl.release();
-        return;
-    }
-
-    RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
-    UChar* data;
-    RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToAppend, data);
-    StringImpl::copyChars(data, m_impl->characters16(), strLength);
-    StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
-    m_impl = newImpl.release();
-}
-
-void String::append(const UChar* charactersToAppend, unsigned lengthToAppend)
-{
-    if (!m_impl) {
-        if (!charactersToAppend)
-            return;
-        m_impl = StringImpl::create(charactersToAppend, lengthToAppend);
-        return;
-    }
-
-    if (!lengthToAppend)
-        return;
-
-    unsigned strLength = m_impl->length();
-
-    ASSERT(charactersToAppend);
-    RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
-    UChar* data;
-    RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
-    if (m_impl->is8Bit())
-        StringImpl::copyChars(data, characters8(), strLength);
-    else
-        StringImpl::copyChars(data, characters16(), strLength);
-    StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
-    m_impl = newImpl.release();
-}
-
 template<typename CharType>
 PassRefPtr<StringImpl> insertInternal(PassRefPtr<StringImpl> impl, const CharType* charactersToInsert, unsigned lengthToInsert, unsigned position)
 {
     if (!lengthToInsert)
         return impl;
 
     ASSERT(charactersToInsert);
     UChar* data; // FIXME: We should be able to create an 8 bit string here.
     RELEASE_ASSERT(lengthToInsert <= std::numeric_limits<unsigned>::max() - impl->length());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(impl->length() + lengthToInsert, data);
 
     if (impl->is8Bit())
         StringImpl::copyChars(data, impl->characters8(), position);
     else
         StringImpl::copyChars(data, impl->characters16(), position);
 
     StringImpl::copyChars(data + position, charactersToInsert, lengthToInsert);
 
     if (impl->is8Bit())
         StringImpl::copyChars(data + position + lengthToInsert, impl->characters8() + position, impl->length() - position);
     else
         StringImpl::copyChars(data + position + lengthToInsert, impl->characters16() + position, impl->length() - position);
 
     return newImpl.release();
 }
 
-void String::insert(const UChar* charactersToInsert, unsigned lengthToInsert, unsigned position)
+void String::insert(const StringView& string, unsigned position)
 {
-    if (position >= length()) {
-        append(charactersToInsert, lengthToInsert);
+    if (string.isEmpty()) {
+        if (string.isNull())
+            return;
+        if (isNull())
+            m_impl = string.toString().releaseImpl();
         return;
     }
-    ASSERT(m_impl);
-    m_impl = insertInternal(m_impl.release(), charactersToInsert, lengthToInsert, position);
-}
 
-void String::insert(const LChar* charactersToInsert, unsigned lengthToInsert, unsigned position)
-{
     if (position >= length()) {
-        append(charactersToInsert, lengthToInsert);
+        if (string.is8Bit())
+            append(string);
+        else
+            append(string);
         return;
     }
-    ASSERT(m_impl);
-    m_impl = insertInternal(m_impl.release(), charactersToInsert, lengthToInsert, position);
+
+    DCHECK(m_impl);
+    if (string.is8Bit())
+        m_impl = insertInternal(m_impl.release(), string.characters8(), string.length(), position);
+    else
+        m_impl = insertInternal(m_impl.release(), string.characters16(), string.length(), position);
 }
 
 UChar32 String::characterStartingAt(unsigned i) const
 {
     if (!m_impl || i >= m_impl->length())
         return 0;
     return m_impl->characterStartingAt(i);
 }
 
 void String::ensure16Bit()
@@ skipping 713 matching lines @@
     buffer.append('\0');
     return buffer;
 }
 
 Vector<char> asciiDebug(String& string)
 {
     return asciiDebug(string.impl());
 }
 
 #endif