Implement StringImpl sharing for StringView::toString().

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

 /*
  * Copyright (C) 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2012 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 52 matching lines @@
             m_length = other.m_length;
             return;
         }
 
         if (other.is8Bit())
             append(other.characters8(), other.m_length);
         else
             append(other.characters16(), other.m_length);
     }
 
-    // TODO(esprehn): This method is just duplicating what StringView itself
-    // does. Remove it and replace callers with append(StringView(string, offset, length)).
+    // NOTE: The semantics of this are different than StringView(..., offset, length)
+    // in that an invalid offset or invalid length is a no-op instead of an
+    // error.
+    // TODO(esprehn): We should probably unify the semantics instead.
     void append(const StringView& string, unsigned offset, unsigned length)
     {
-        if (!string.length())
-            return;
-
         unsigned extent = offset + length;
         if (extent < offset || extent > string.length())
             return;
 
-        if (string.is8Bit())
-            append(string.characters8() + offset, length);
-        else
-            append(string.characters16() + offset, length);
+        // We can't do this before the above check since StringView's constructor
+        // doesn't accept invalid offsets or lengths.
+        append(StringView(string, offset, length));
     }
 
     void append(const StringView& string)
     {
-        if (!string.length())
+        if (string.isEmpty())
             return;
 
+        // If we're appending to an empty builder, and there is not a buffer
+        // (reserveCapacity has not been called), then share the impl if
+        // possible.
+        //
+        // This is important to avoid string copies inside dom operations like
+        // Node::textContent when there's only a single Text node child, or
+        // inside the parser in the common case when flushing buffered text to
+        // a Text node.
+        StringImpl* impl = string.sharedImpl();
+        if (!m_length && !m_buffer && impl) {
+            m_string = impl;

[haraken, 2016/06/06 02:28:52]

Don't we need to set m_buffer to impl?

[esprehn, 2016/06/06 04:42:21]

Nope, m_buffer is for when we have an overallocated string created with the
allocate uninitialized method. Since the string we're adding here is coming from
outside the builder its immutable and we can't set m_buffer, and it's also
correctly sized already, so there's no extra room.

+            m_length = impl->length();
+            m_is8Bit = impl->is8Bit();
+            return;
+        }
+
         if (string.is8Bit())
             append(string.characters8(), string.length());
         else
             append(string.characters16(), string.length());
     }
 
     void append(UChar c)
     {
         if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
             if (!m_is8Bit) {
@@ skipping 263 matching lines @@
 inline bool operator==(const StringBuilder& a, const String& b) { return equal(a, b); }
 inline bool operator!=(const StringBuilder& a, const String& b) { return !equal(a, b); }
 inline bool operator==(const String& a, const StringBuilder& b) { return equal(b, a); }
 inline bool operator!=(const String& a, const StringBuilder& b) { return !equal(b, a); }
 
 } // namespace WTF
 
 using WTF::StringBuilder;
 
 #endif // StringBuilder_h