SerializedScriptValue's Writer calls realloc a lot

Source/bindings/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 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 514 matching lines @@
         doWriteUint32(length);
     }
 
     void writeDenseArray(uint32_t numProperties, uint32_t length)
     {
         append(DenseArrayTag);
         doWriteUint32(numProperties);
         doWriteUint32(length);
     }
 
-    StringBuffer<BufferValueType>& data()
+    String takeWireString()
     {
+        COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
         fillHole();
-        return m_buffer;
+        String data = String::adopt(m_buffer);
+        data.impl()->truncateAssumingIsolated((m_position + 1) / sizeof(BufferValueType));
+        return data;
     }
 
     void writeReferenceCount(uint32_t numberOfReferences)
     {
         append(ReferenceCountTag);
         doWriteUint32(numberOfReferences);
     }
 
     void writeGenerateFreshObject()
     {
@@ skipping 87 matching lines @@
         *byteAt(m_position++) = b;
     }
 
     void append(const uint8_t* data, int length)
     {
         ensureSpace(length);
         memcpy(byteAt(m_position), data, length);
         m_position += length;
     }
 
-    void ensureSpace(int extra)
+    static unsigned expandedCapacity(unsigned capacity, unsigned newLength)
+    {
+        static const unsigned minimumCapacity = 16;
+        return std::max(capacity, std::max(minimumCapacity, newLength * 2));
+    }
+
+    void ensureSpace(unsigned extra)
     {
         COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
-        m_buffer.resize((m_position + extra + 1) / 2); // "+ 1" to round up.
+        unsigned oldCapacity = m_buffer.length() * sizeof(BufferValueType);
+        unsigned newCapacity = expandedCapacity(oldCapacity, m_position + extra);
+        m_buffer.resize((newCapacity + 1) / sizeof(BufferValueType)); // "+ 1" to round up.
     }
 
     void fillHole()
     {
         COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
         // If the writer is at odd position in the buffer, then one of
         // the bytes in the last UChar is not initialized.
         if (m_position % 2)
             *byteAt(m_position) = static_cast<uint8_t>(PaddingTag);
     }
@@ skipping 1602 matching lines @@
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(const String& data)
 {
     return create(data, v8::Isolate::GetCurrent());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(const String& data, v8::Isolate* isolate)
 {
     Writer writer(isolate);
     writer.writeWebCoreString(data);
-    String wireData = String::adopt(writer.data());
+    String wireData = writer.takeWireString();
     return adoptRef(new SerializedScriptValue(wireData));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::create()
 {
     return adoptRef(new SerializedScriptValue());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::nullValue()
 {
     return nullValue(v8::Isolate::GetCurrent());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::nullValue(v8::Isolate* isolate)
 {
     Writer writer(isolate);
     writer.writeNull();
-    String wireData = String::adopt(writer.data());
+    String wireData = writer.takeWireString();
     return adoptRef(new SerializedScriptValue(wireData));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::undefinedValue()
 {
     return undefinedValue(v8::Isolate::GetCurrent());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::undefinedValue(v8::Isolate* isolate)
 {
     Writer writer(isolate);
     writer.writeUndefined();
-    String wireData = String::adopt(writer.data());
+    String wireData = writer.takeWireString();
     return adoptRef(new SerializedScriptValue(wireData));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::booleanValue(bool value)
 {
     return booleanValue(value, v8::Isolate::GetCurrent());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::booleanValue(bool value, v8::Isolate* isolate)
 {
     Writer writer(isolate);
     if (value)
         writer.writeTrue();
     else
         writer.writeFalse();
-    String wireData = String::adopt(writer.data());
+    String wireData = writer.takeWireString();
     return adoptRef(new SerializedScriptValue(wireData));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::numberValue(double value)
 {
     return numberValue(value, v8::Isolate::GetCurrent());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::numberValue(double value, v8::Isolate* isolate)
 {
     Writer writer(isolate);
     writer.writeNumber(value);
-    String wireData = String::adopt(writer.data());
+    String wireData = writer.takeWireString();
     return adoptRef(new SerializedScriptValue(wireData));
 }
 
 // Convert serialized string to big endian wire data.
 void SerializedScriptValue::toWireBytes(Vector<char>& result) const
 {
     ASSERT(result.isEmpty());
     size_t length = m_data.length();
     result.resize(length * sizeof(UChar));
     UChar* dst = reinterpret_cast<UChar*>(result.data());
@@ skipping 113 matching lines @@
         if (policy == ThrowExceptions)
             setDOMException(InvalidStateError, isolate);
         return;
     case Serializer::JSFailure:
         // If there was a JS failure (but no exception), there's not
         // much we can do except for unwinding the C++ stack by
         // pretending there was a JS exception.
         didThrow = true;
         return;
     case Serializer::Success:
-        // FIXME: This call to isolatedCopy should be redundant.
-        m_data = String(String::adopt(writer.data())).isolatedCopy();
+        m_data = writer.takeWireString();
+        ASSERT(m_data.impl()->hasOneRef());
         if (arrayBuffers && arrayBuffers->size())
             m_arrayBufferContentsArray = transferArrayBuffers(*arrayBuffers, didThrow, isolate);
         return;
     case Serializer::JSException:
         // We should never get here because this case was handled above.
         break;
     }
     ASSERT_NOT_REACHED();
 }
 
@@ skipping 53 matching lines @@
         v8::V8::AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 uint32_t SerializedScriptValue::wireFormatVersion()
 {
     return WebCore::wireFormatVersion;
 }
 
 } // namespace WebCore