Allocate space in StringBuilder for m_string and the new bytes.

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

 /*
  * Copyright (C) 2010 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 84 matching lines @@
 {
     if (!hasBuffer())
         return 0;
     if (m_is8Bit)
         return m_buffer8->capacity();
     return m_buffer16->capacity();
 }
 
 void StringBuilder::reserveCapacity(unsigned newCapacity)
 {
-    if (m_is8Bit) {
-        ensureBuffer8();
-        m_buffer8->reserveCapacity(newCapacity);
-    } else {
-        ensureBuffer16();
-        m_buffer16->reserveCapacity(newCapacity);
-    }
+    if (m_is8Bit)
+        ensureBuffer8(newCapacity);
+    else
+        ensureBuffer16(newCapacity);
 }
 
 void StringBuilder::resize(unsigned newSize)
 {
     DCHECK_LE(newSize, m_length);
     m_length = newSize;
     m_string = String();
     if (!hasBuffer())
         return;
     if (m_is8Bit)
         m_buffer8->resize(newSize);
     else
         m_buffer16->resize(newSize);
 }
 
-void StringBuilder::createBuffer8()
+void StringBuilder::createBuffer8(unsigned addedSize)
 {
     DCHECK(!hasBuffer());
     DCHECK(m_is8Bit);
     m_buffer8 = new Buffer8;
+    // createBuffer is called right before appending addedSize more bytes. We
+    // want to ensure we have enough space to fit m_string plus the added
+    // size.
+    //
+    // We also ensure that we have at least the initialBufferSize of extra space
+    // for appending new bytes to avoid future mallocs for appending short
+    // strings or single characters. This is a no-op if m_length == 0 since
+    // initialBufferSize() is the same as the inline capacity of the vector.
+    // This allows doing append(string); append('\0') without extra mallocs.
+    m_buffer8->reserveInitialCapacity(m_length + std::max(addedSize, initialBufferSize()));

[haraken, 2016/07/01 02:01:03]

I don't quite see any reason you want to take std::max(addedSize,
initialBufferSize()). I guess you can just allocate |m_length + addedSize +
someSlack|.

     m_length = 0;
     // Must keep a ref to the string since append will clear it.
     String string(m_string);
     append(string);
 }
 
-void StringBuilder::createBuffer16()
+void StringBuilder::createBuffer16(unsigned addedSize)
 {
     DCHECK(m_is8Bit || !hasBuffer());
     Buffer8 buffer8;
     unsigned length = m_length;
     if (m_buffer8) {
         m_buffer8->swap(buffer8);
         delete m_buffer8;
     }
     m_buffer16 = new Buffer16;
+    // See createBuffer8's call to reserveInitialCapacity for why we do this.
+    m_buffer16->reserveInitialCapacity(m_length + std::max(addedSize, initialBufferSize()));
     m_is8Bit = false;
     m_length = 0;
     if (!buffer8.isEmpty()) {
         append(buffer8.data(), length);
         return;
     }
     // Must keep a ref to the string since append will clear it.
     String string(m_string);
     append(string);
 }
 
 void StringBuilder::append(const UChar* characters, unsigned length)
 {
     if (!length)
         return;
     DCHECK(characters);
 
     // If there's only one char we use append(UChar) instead since it will
     // check for latin1 and avoid converting to 16bit if possible.
     if (length == 1) {
         append(*characters);
         return;
     }
 
-    ensureBuffer16();
+    ensureBuffer16(length);
     m_string = String();
     m_buffer16->append(characters, length);
     m_length += length;
 }
 
 void StringBuilder::append(const LChar* characters, unsigned length)
 {
     if (!length)
         return;
     DCHECK(characters);
 
     if (m_is8Bit) {
-        ensureBuffer8();
+        ensureBuffer8(length);
         m_string = String();
         m_buffer8->append(characters, length);
         m_length += length;
         return;
     }
 
-    ensureBuffer16();
+    ensureBuffer16(length);
     m_string = String();
     m_buffer16->reserveCapacity(m_buffer16->size() + length);
     for (size_t i = 0; i < length; ++i)
         m_buffer16->uncheckedAppend(characters[i]);
     m_length += length;
 }
 
 template<typename IntegerType>
 static void appendIntegerInternal(StringBuilder& builder, IntegerType input)
 {
@@ skipping 31 matching lines @@
     appendIntegerInternal(*this, number);
 }
 
 void StringBuilder::appendNumber(double number, unsigned precision, TrailingZerosTruncatingPolicy trailingZerosTruncatingPolicy)
 {
     NumberToStringBuffer buffer;
     append(numberToFixedPrecisionString(number, precision, buffer, trailingZerosTruncatingPolicy == TruncateTrailingZeros));
 }
 
 } // namespace WTF