Remove String::adopt(Vector<UChar>)

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 262 matching lines @@
 
 private:
     ZigZag();
 };
 
 // Writer is responsible for serializing primitive types and storing
 // information used to reconstruct composite types.
 class Writer {
     WTF_MAKE_NONCOPYABLE(Writer);
 public:
-    Writer(v8::Isolate* isolate)
+    explicit Writer(v8::Isolate* isolate)
         : m_position(0)
         , m_isolate(isolate)
     {
     }
 
     // Write functions for primitive types.
 
     void writeUndefined() { append(UndefinedTag); }
 
     void writeNull() { append(NullTag); }
@@ skipping 231 matching lines @@
         doWriteUint32(length);
     }
 
     void writeDenseArray(uint32_t numProperties, uint32_t length)
     {
         append(DenseArrayTag);
         doWriteUint32(numProperties);
         doWriteUint32(length);
     }
 
-    Vector<BufferValueType>& data()
+    StringBuffer<BufferValueType>& data()
     {
         fillHole();
         return m_buffer;
     }
 
     void writeReferenceCount(uint32_t numberOfReferences)
     {
         append(ReferenceCountTag);
         doWriteUint32(numberOfReferences);
     }
@@ skipping 93 matching lines @@
     void append(const uint8_t* data, int length)
     {
         ensureSpace(length);
         memcpy(byteAt(m_position), data, length);
         m_position += length;
     }
 
     void ensureSpace(int extra)
     {
         COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
-        m_buffer.grow((m_position + extra + 1) / 2); // "+ 1" to round up.
+        m_buffer.resize((m_position + extra + 1) / 2); // "+ 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);
     }
 
     uint8_t* byteAt(int position)
     {
-        return reinterpret_cast<uint8_t*>(m_buffer.data()) + position;
+        return reinterpret_cast<uint8_t*>(m_buffer.characters()) + position;
     }
 
     int v8StringWriteOptions()
     {
         return v8::String::NO_NULL_TERMINATION;
     }
 
-    Vector<BufferValueType> m_buffer;
+    StringBuffer<BufferValueType> m_buffer;
     unsigned m_position;
     v8::Isolate* m_isolate;
 };
 
 static v8::Handle<v8::Object> toV8Object(MessagePort* impl, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Handle<v8::Object>();
     v8::Handle<v8::Value> wrapper = toV8(impl, v8::Handle<v8::Object>(), isolate);
     ASSERT(wrapper->IsObject());
@@ skipping 1580 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 = StringImpl::adopt(writer.data());
+    String wireData = String::adopt(writer.data());
     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 = StringImpl::adopt(writer.data());
+    String wireData = String::adopt(writer.data());
     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 = StringImpl::adopt(writer.data());
+    String wireData = String::adopt(writer.data());
     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 = StringImpl::adopt(writer.data());
+    String wireData = String::adopt(writer.data());
     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 = StringImpl::adopt(writer.data());
+    String wireData = String::adopt(writer.data());
     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 111 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:
-        m_data = String(StringImpl::adopt(writer.data())).isolatedCopy();
+        // FIXME: This call to isolatedCopy should be redundant.
+        m_data = String(String::adopt(writer.data())).isolatedCopy();
         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