Changeset 57133 in webkit

Timestamp:

Apr 6, 2010 1:12:48 AM (14 years ago)

Author:

pfeldman@chromium.org

Message:

2010-04-06 Pavel Feldman <​pfeldman@chromium.org>

Not reviewed: reverting v8 change at r57079 for crashing Chromium layout tests.

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• bindings/v8/SerializedScriptValue.cpp (modified) (23 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-04-06  Pavel Feldman  <pfeldman@chromium.org>
+
+        Not reviewed: reverting v8 change at r57079 for crashing Chromium layout tests.
+
 2010-04-05  MORITA Hajime  <morrita@google.com>
 

trunk/WebCore/bindings/v8/SerializedScriptValue.cpp

@@ -32 +32 @@
 #include "SerializedScriptValue.h"
 
-#include "ByteArray.h"
-#include "CanvasPixelArray.h"
-#include "ImageData.h"
 #include "SharedBuffer.h"
-#include "V8ImageData.h"
 
 #include <v8.h>
@@ -45 +41 @@
 // FIXME:
 // - catch V8 exceptions
+// - be ready to get empty handles
 // - consider crashing in debug mode on deserialization errors
 
@@ -64 +61 @@
     StringTag = 'S',
     Int32Tag = 'I',
-    Uint32Tag = 'U',
-    DateTag = 'D',
     NumberTag = 'N',
-    ImageDataTag = '#',
+    ObjectTag = '{',
     ArrayTag = '[',
-    ObjectTag = '{',
-    SparseArrayTag = '@',
 };
+
+// Helpers to do verbose handle casts.
+
+template <typename T, typename U>
+static v8::Handle<T> handleCast(v8::Handle<U> handle) { return v8::Handle<T>::Cast(handle); }
+
+template <typename T, typename U>
+static v8::Local<T> handleCast(v8::Local<U> handle) { return v8::Local<T>::Cast(handle); }
 
 static bool shouldCheckForCycles(int depth)
@@ -118 +119 @@
 class Writer : Noncopyable {
 public:
-    Writer()
-        : m_position(0)
+    Writer() : m_position(0)
     {
     }
@@ -135 +135 @@
     void writeString(const char* data, int length)
     {
-        ASSERT(length >= 0);
         append(StringTag);
         doWriteUint32(static_cast<uint32_t>(length));
-        append(reinterpret_cast<const uint8_t*>(data), length);
+        append(data, length);
     }
 
@@ -147 +146 @@
     }
 
-    void writeUint32(uint32_t value)
-    {
-        append(Uint32Tag);
-        doWriteUint32(value);
-    }
-
-    void writeDate(double numberValue)
-    {
-        append(DateTag);
-        doWriteNumber(numberValue);
-    }
-
     void writeNumber(double number)
     {
         append(NumberTag);
-        doWriteNumber(number);
-    }
-
-    void writeImageData(uint32_t width, uint32_t height, const uint8_t* pixelData, uint32_t pixelDataLength)
-    {
-        append(ImageDataTag);
-        doWriteUint32(width);
-        doWriteUint32(height);
-        doWriteUint32(pixelDataLength);
-        append(pixelData, pixelDataLength);
-    }
-
-    void writeArray(uint32_t length)
-    {
-        append(ArrayTag);
-        doWriteUint32(length);
-    }
-
-    void writeObject(uint32_t numProperties)
-    {
-        append(ObjectTag);
-        doWriteUint32(numProperties);
-    }
-
-    void writeSparseArray(uint32_t numProperties, uint32_t length)
-    {
-        append(SparseArrayTag);
-        doWriteUint32(numProperties);
-        doWriteUint32(length);
+        append(reinterpret_cast<char*>(&number), sizeof(number));
+    }
+
+    // Records that a composite object can be constructed by using
+    // |length| previously stored values.
+    void endComposite(SerializationTag tag, int32_t length)
+    {
+        ASSERT(tag == ObjectTag || tag == ArrayTag);
+        append(tag);
+        doWriteUint32(static_cast<uint32_t>(length));
     }
 
@@ -203 +171 @@
     {
         while (true) {
-            uint8_t b = (value & varIntMask);
+            char b = (value & varIntMask);
             value >>= varIntShift;
             if (!value) {
@@ -213 +181 @@
     }
 
-    void doWriteNumber(double number)
-    {
-        append(reinterpret_cast<uint8_t*>(&number), sizeof(number));
-    }
-
     void append(SerializationTag tag)
     {
-        append(static_cast<uint8_t>(tag));
-    }
-
-    void append(uint8_t b)
+        append(static_cast<char>(tag));
+    }
+
+    void append(char b)
     {
         ensureSpace(1);
-        *byteAt(m_position++) = b;
-    }
-
-    void append(const uint8_t* data, int length)
+        *charAt(m_position++) = b;
+    }
+
+    void append(const char* data, int length)
     {
         ensureSpace(length);
-        memcpy(byteAt(m_position), data, length);
+        memcpy(charAt(m_position), data, length);
         m_position += length;
     }
@@ -248 +211 @@
         // 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; }
+            *charAt(m_position) = static_cast<char>(PaddingTag);
+    }
+
+    char* charAt(int position) { return reinterpret_cast<char*>(m_buffer.data()) + position; }
 
     Vector<BufferValueType> m_buffer;
@@ -258 +221 @@
 
 class Serializer {
-    class StateBase;
 public:
     explicit Serializer(Writer& writer)
         : m_writer(writer)
+        , m_state(0)
         , m_depth(0)
-        , m_hasError(false)
     {
     }
@@ -270 +232 @@
     {
         v8::HandleScope scope;
-        StateBase* state = doSerialize(value, 0);
-        while (state)
-            state = state->advance(*this);
-        return !m_hasError;
-    }
-
-    // Functions used by serialization states.
-
-    StateBase* doSerialize(v8::Handle<v8::Value> value, StateBase* next);
-
-    StateBase* writeArray(uint32_t length, StateBase* state)
-    {
-        m_writer.writeArray(length);
-        return pop(state);
-    }
-
-    StateBase* writeObject(uint32_t numProperties, StateBase* state)
-    {
-        m_writer.writeObject(numProperties);
-        return pop(state);
-    }
-
-    StateBase* writeSparseArray(uint32_t numProperties, uint32_t length, StateBase* state)
-    {
-        m_writer.writeSparseArray(numProperties, length);
-        return pop(state);
+        StackCleaner cleaner(&m_state);
+        if (!doSerialize(value))
+            return false;
+        while (top()) {
+            int length;
+            while (!top()->isDone(&length)) {
+                // Note that doSerialize() can change current top().
+                if (!doSerialize(top()->advance()))
+                    return false;
+            }
+            m_writer.endComposite(top()->tag(), length);
+            pop();
+        }
+        return true;
     }
 
@@ -305 +255 @@
         // Link to the next state to form a stack.
         StateBase* nextState() { return m_next; }
+        void setNextState(StateBase* next) { m_next = next; }
 
         // Composite object we're processing in this state.
         v8::Handle<v8::Value> composite() { return m_composite; }
 
-        // Serializes (a part of) the current composite and returns
-        // the next state to process or null when this is the final
-        // state.
-        virtual StateBase* advance(Serializer&) = 0;
+        // Serialization tag for the current composite.
+        virtual SerializationTag tag() const = 0;
+
+        // Returns whether iteration over subobjects of the current
+        // composite object is done. If yes, |*length| is set to the
+        // number of subobjects.
+        virtual bool isDone(int* length) = 0;
+
+        // Advances to the next subobject.
+        // Requires: !this->isDone().
+        virtual v8::Local<v8::Value> advance() = 0;
 
     protected:
-        StateBase(v8::Handle<v8::Value> composite, StateBase* next)
-            : m_composite(composite)
-            , m_next(next)
+        StateBase(v8::Handle<v8::Value> composite)
+            : m_next(0)
+            , m_composite(composite)
         {
         }
 
     private:
+        StateBase* m_next;
         v8::Handle<v8::Value> m_composite;
-        StateBase* m_next;
     };
 
-    // Dummy state that is used to signal serialization errors.
-    class ErrorState : public StateBase {
-    public:
-        ErrorState()
-            : StateBase(v8::Handle<v8::Value>(), 0)
-        {
-        }
-
-        virtual StateBase* advance(Serializer&)
-        {
-            delete this;
-            return 0;
-        }
-    };
-
-    template <typename T>
+    template <typename T, SerializationTag compositeTag>
     class State : public StateBase {
     public:
-        v8::Handle<T> composite() { return v8::Handle<T>::Cast(StateBase::composite()); }
+        v8::Handle<T> composite() { return handleCast<T>(StateBase::composite()); }
+
+        virtual SerializationTag tag() const { return compositeTag; }
 
     protected:
-        State(v8::Handle<T> composite, StateBase* next)
-            : StateBase(composite, next)
+        explicit State(v8::Handle<T> composite) : StateBase(composite)
         {
         }
     };
 
-#if 0
-    // Currently unused, see comment in newArrayState.
-    class ArrayState : public State<v8::Array> {
+    // Helper to clean up the state stack in case of errors.
+    class StackCleaner : Noncopyable {
     public:
-        ArrayState(v8::Handle<v8::Array> array, StateBase* next)
-            : State<v8::Array>(array, next)
-            , m_index(-1)
-        {
-        }
-
-        virtual StateBase* advance(Serializer& serializer)
-        {
-            ++m_index;
-            for (; m_index < composite()->Length(); ++m_index) {
-                if (StateBase* newState = serializer.doSerialize(composite()->Get(m_index), this))
-                    return newState;
+        explicit StackCleaner(StateBase** stack) : m_stack(stack)
+        {
+        }
+
+        ~StackCleaner()
+        {
+            StateBase* state = *m_stack;
+            while (state) {
+                StateBase* tmp = state->nextState();
+                delete state;
+                state = tmp;
             }
-            return serializer.writeArray(composite()->Length(), this);
+            *m_stack = 0;
+        }
+
+    private:
+        StateBase** m_stack;
+    };
+
+    class ArrayState : public State<v8::Array, ArrayTag> {
+    public:
+        ArrayState(v8::Handle<v8::Array> array)
+            : State<v8::Array, ArrayTag>(array)
+            , m_index(0)
+        {
+        }
+
+        virtual bool isDone(int* length)
+        {
+            *length = composite()->Length();
+            return static_cast<int>(m_index) >= *length;
+        }
+
+        virtual v8::Local<v8::Value> advance()
+        {
+            ASSERT(m_index < composite()->Length());
+            v8::HandleScope scope;
+            return scope.Close(composite()->Get(v8::Integer::New(m_index++)));
         }
 
@@ -376 +343 @@
         unsigned m_index;
     };
-#endif
-
-    class AbstractObjectState : public State<v8::Object> {
+
+    class ObjectState : public State<v8::Object, ObjectTag> {
     public:
-        AbstractObjectState(v8::Handle<v8::Object> object, StateBase* next)
-            : State<v8::Object>(object, next)
+        ObjectState(v8::Handle<v8::Object> object)
+            : State<v8::Object, ObjectTag>(object)
             , m_propertyNames(object->GetPropertyNames())
             , m_index(-1)
-            , m_nameDone(false)
-        {
-        }
-
-        virtual StateBase* advance(Serializer& serializer)
-        {
+            , m_length(0)
+        {
+            nextProperty();
+        }
+
+        virtual bool isDone(int* length)
+        {
+            *length = m_length;
+            return m_index >= 2 * m_propertyNames->Length();
+        }
+
+        virtual v8::Local<v8::Value> advance()
+        {
+            ASSERT(m_index < 2 * m_propertyNames->Length());
+            if (!(m_index % 2)) {
+                ++m_index;
+                return m_propertyName;
+            }
+            v8::Local<v8::Value> result = composite()->Get(m_propertyName);
+            nextProperty();
+            return result;
+        }
+
+    private:
+        void nextProperty()
+        {
+            v8::HandleScope scope;
             ++m_index;
-            for (; m_index < m_propertyNames->Length(); ++m_index) {
-                if (m_propertyName.IsEmpty()) {
-                    v8::Local<v8::Value> propertyName = m_propertyNames->Get(m_index);
-                    if ((propertyName->IsString() && composite()->HasRealNamedProperty(propertyName.As<v8::String>()))
-                        || (propertyName->IsUint32() && composite()->HasRealIndexedProperty(propertyName->Uint32Value()))) {
-                        m_propertyName = propertyName;
-                    } else
-                        continue;
+            ASSERT(!(m_index % 2));
+            for (; m_index < 2 * m_propertyNames->Length(); m_index += 2) {
+                v8::Local<v8::Value> propertyName = m_propertyNames->Get(v8::Integer::New(m_index / 2));
+                if ((propertyName->IsString() && composite()->HasRealNamedProperty(handleCast<v8::String>(propertyName)))
+                    || (propertyName->IsInt32() && composite()->HasRealIndexedProperty(propertyName->Uint32Value()))) {
+                    m_propertyName = scope.Close(propertyName);
+                    m_length += 2;
+                    return;
                 }
-                ASSERT(!m_propertyName.IsEmpty());
-                if (!m_nameDone) {
-                    m_nameDone = true;
-                    if (StateBase* newState = serializer.doSerialize(m_propertyName, this))
-                        return newState;
-                }
-                v8::Local<v8::Value> value = composite()->Get(m_propertyName);
-                m_nameDone = false;
-                m_propertyName.Clear();
-                if (StateBase* newState = serializer.doSerialize(value, this))
-                    return newState;
             }
-            return objectDone(m_index, serializer);
-        }
-
-    protected:
-        virtual StateBase* objectDone(unsigned numProperties, Serializer&) = 0;
-
-    private:
+        }
+
         v8::Local<v8::Array> m_propertyNames;
         v8::Local<v8::Value> m_propertyName;
         unsigned m_index;
-        bool m_nameDone;
+        unsigned m_length;
     };
 
-    class ObjectState : public AbstractObjectState {
-    public:
-        ObjectState(v8::Handle<v8::Object> object, StateBase* next)
-            : AbstractObjectState(object, next)
-        {
-        }
-
-    protected:
-        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
-        {
-            return serializer.writeObject(numProperties, this);
-        }
-    };
-
-    class SparseArrayState : public AbstractObjectState {
-    public:
-        SparseArrayState(v8::Handle<v8::Array> array, StateBase* next)
-            : AbstractObjectState(array, next)
-        {
-        }
-
-    protected:
-        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
-        {
-            return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
-        }
-    };
-
-    StateBase* push(StateBase* state)
-    {
-        ASSERT(state);
+    bool doSerialize(v8::Handle<v8::Value> value)
+    {
+        if (value->IsUndefined())
+            m_writer.writeUndefined();
+        else if (value->IsNull())
+            m_writer.writeNull();
+        else if (value->IsTrue())
+            m_writer.writeTrue();
+        else if (value->IsFalse())
+            m_writer.writeFalse();
+        else if (value->IsInt32())
+            m_writer.writeInt32(value->Int32Value());
+        else if (value->IsNumber())
+            m_writer.writeNumber(handleCast<v8::Number>(value)->Value());
+        else if (value->IsString()) {
+            v8::String::Utf8Value stringValue(value);
+            m_writer.writeString(*stringValue, stringValue.length());
+        } else if (value->IsArray()) {
+            if (!checkComposite(value))
+                return false;
+            push(new ArrayState(handleCast<v8::Array>(value)));
+        } else if (value->IsObject()) {
+            if (!checkComposite(value))
+                return false;
+            push(new ObjectState(handleCast<v8::Object>(value)));
+            // FIXME:
+            // - check not a wrapper
+            // - support File, ImageData, etc.
+        }
+        return true;
+    }
+
+    void push(StateBase* state)
+    {
+        state->setNextState(m_state);
+        m_state = state;
         ++m_depth;
-        return checkComposite(state) ? state : handleError(state);
-    }
-
-    StateBase* pop(StateBase* state)
-    {
-        ASSERT(state);
+    }
+
+    StateBase* top() { return m_state; }
+
+    void pop()
+    {
+        if (!m_state)
+            return;
+        StateBase* top = m_state;
+        m_state = top->nextState();
+        delete top;
         --m_depth;
-        StateBase* next = state->nextState();
-        delete state;
-        return next;
-    }
-
-    StateBase* handleError(StateBase* state)
-    {
-        m_hasError = true;
-        while (state) {
-            StateBase* tmp = state->nextState();
-            delete tmp;
-            state = tmp;
-        }
-        return new ErrorState;
-    }
-
-    bool checkComposite(StateBase* top)
-    {
-        ASSERT(top);
+    }
+
+    bool checkComposite(v8::Handle<v8::Value> composite)
+    {
         if (m_depth > maxDepth)
             return false;
         if (!shouldCheckForCycles(m_depth))
             return true;
-        v8::Handle<v8::Value> composite = top->composite();
-        for (StateBase* state = top->nextState(); state; state = state->nextState()) {
+        for (StateBase* state = top(); state; state = state->nextState()) {
             if (state->composite() == composite)
                 return false;
@@ -495 +460 @@
     }
 
-    void writeString(v8::Handle<v8::Value> value)
-    {
-        v8::String::Utf8Value stringValue(value);
-        m_writer.writeString(*stringValue, stringValue.length());
-    }
-
-    void writeImageData(v8::Handle<v8::Value> value)
-    {
-        ImageData* imageData = V8ImageData::toNative(value.As<v8::Object>());
-        if (!imageData)
-            return;
-        WTF::ByteArray* pixelArray = imageData->data()->data();
-        m_writer.writeImageData(imageData->width(), imageData->height(), pixelArray->data(), pixelArray->length());
-    }
-
-    static StateBase* newArrayState(v8::Handle<v8::Array> array, StateBase* next)
-    {
-        // FIXME: use plain Array state when we can quickly check that
-        // an array is not sparse and has only indexed properties.
-        return new SparseArrayState(array, next);
-    }
-
-    static StateBase* newObjectState(v8::Handle<v8::Object> object, StateBase* next)
-    {
-        // FIXME:
-        // - check not a wrapper
-        // - support File, etc.
-        return new ObjectState(object, next);
-    }
-
     Writer& m_writer;
+    StateBase* m_state;
     int m_depth;
-    bool m_hasError;
-};
-
-Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, StateBase* next)
-{
-    if (value->IsUndefined())
-        m_writer.writeUndefined();
-    else if (value->IsNull())
-        m_writer.writeNull();
-    else if (value->IsTrue())
-        m_writer.writeTrue();
-    else if (value->IsFalse())
-        m_writer.writeFalse();
-    else if (value->IsInt32())
-        m_writer.writeInt32(value->Int32Value());
-    else if (value->IsUint32())
-        m_writer.writeUint32(value->Uint32Value());
-    else if (value->IsDate())
-        m_writer.writeDate(value->NumberValue());
-    else if (value->IsNumber())
-        m_writer.writeNumber(value.As<v8::Number>()->Value());
-    else if (value->IsString())
-        writeString(value);
-    else if (value->IsArray())
-        return push(newArrayState(value.As<v8::Array>(), next));
-    else if (V8ImageData::HasInstance(value))
-        writeImageData(value);
-    else if (value->IsObject())
-        return push(newObjectState(value.As<v8::Object>(), next));
-    return 0;
-}
-
-// Interface used by Reader to create objects of composite types.
-class CompositeCreator {
-public:
-    virtual ~CompositeCreator() { }
-
-    virtual bool createArray(uint32_t length, v8::Handle<v8::Value>* value) = 0;
-    virtual bool createObject(uint32_t numProperties, v8::Handle<v8::Value>* value) = 0;
-    virtual bool createSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value) = 0;
 };
 
@@ -573 +469 @@
 class Reader {
 public:
-    Reader(const uint8_t* buffer, int length)
+    Reader(const char* buffer, int length)
         : m_buffer(buffer)
         , m_length(length)
@@ -583 +479 @@
     bool isEof() const { return m_position >= m_length; }
 
-    bool read(v8::Handle<v8::Value>* value, CompositeCreator& creator)
-    {
-        SerializationTag tag;
-        if (!readTag(&tag))
-            return false;
-        switch (tag) {
+    bool read(SerializationTag* tag, v8::Handle<v8::Value>* value, int* length)
+    {
+        uint32_t rawLength;
+        if (!readTag(tag))
+            return false;
+        switch (*tag) {
         case InvalidTag:
             return false;
         case PaddingTag:
-            return true;
+            break;
         case UndefinedTag:
             *value = v8::Undefined();
@@ -613 +509 @@
                 return false;
             break;
-        case Uint32Tag:
-            if (!readUint32(value))
-                return false;
-            break;
-        case DateTag:
-            if (!readDate(value))
-                return false;
-            break;
         case NumberTag:
             if (!readNumber(value))
                 return false;
             break;
-        case ImageDataTag:
-            if (!readImageData(value))
-                return false;
-            break;
-        case ArrayTag: {
-            uint32_t length;
-            if (!doReadUint32(&length))
-                return false;
-            if (!creator.createArray(length, value))
-                return false;
-            break;
-        }
-        case ObjectTag: {
-            uint32_t numProperties;
-            if (!doReadUint32(&numProperties))
-                return false;
-            if (!creator.createObject(numProperties, value))
-                return false;
-            break;
-        }
-        case SparseArrayTag: {
-            uint32_t numProperties;
-            uint32_t length;
-            if (!doReadUint32(&numProperties))
-                return false;
-            if (!doReadUint32(&length))
-                return false;
-            if (!creator.createSparseArray(numProperties, length, value))
-                return false;
-            break;
-        }
-        default:
-            return false;
-        }
-        return !value->IsEmpty();
+        case ObjectTag:
+        case ArrayTag:
+            if (!doReadUint32(&rawLength))
+                return false;
+            *length = rawLength;
+            break;
+        }
+        return true;
     }
 
@@ -678 +539 @@
         if (m_position + length > m_length)
             return false;
-        *value = v8::String::New(reinterpret_cast<const char*>(m_buffer + m_position), length);
+        *value = v8::String::New(m_buffer + m_position, length);
         m_position += length;
         return true;
@@ -692 +553 @@
     }
 
-    bool readUint32(v8::Handle<v8::Value>* value)
-    {
-        uint32_t rawValue;
-        if (!doReadUint32(&rawValue))
-            return false;
-        *value = v8::Integer::New(rawValue);
-        return true;
-    }
-
-    bool readDate(v8::Handle<v8::Value>* value)
-    {
-        double numberValue;
-        if (!doReadNumber(&numberValue))
-            return false;
-        *value = v8::Date::New(numberValue);
-        return true;
-    }
-
     bool readNumber(v8::Handle<v8::Value>* value)
     {
+        if (m_position + sizeof(double) > m_length)
+            return false;
         double number;
-        if (!doReadNumber(&number))
-            return false;
+        char* numberAsByteArray = reinterpret_cast<char*>(&number);
+        for (unsigned i = 0; i < sizeof(double); ++i)
+            numberAsByteArray[i] = m_buffer[m_position++];
         *value = v8::Number::New(number);
         return true;
     }
 
-    bool readImageData(v8::Handle<v8::Value>* value)
-    {
-        uint32_t width;
-        uint32_t height;
-        uint32_t pixelDataLength;
-        if (!doReadUint32(&width))
-            return false;
-        if (!doReadUint32(&height))
-            return false;
-        if (!doReadUint32(&pixelDataLength))
-            return false;
-        if (m_position + pixelDataLength > m_length)
-            return false;
-        PassRefPtr<ImageData> imageData = ImageData::create(width, height);
-        WTF::ByteArray* pixelArray = imageData->data()->data();
-        ASSERT(pixelArray);
-        ASSERT(pixelArray->length() >= pixelDataLength);
-        memcpy(pixelArray->data(), m_buffer + m_position, pixelDataLength);
-        m_position += pixelDataLength;
-        *value = toV8(imageData);
-        return true;
-    }
-
     bool doReadUint32(uint32_t* value)
     {
         *value = 0;
-        uint8_t currentByte;
+        char currentByte;
         int shift = 0;
         do {
@@ -757 +580 @@
     }
 
-    bool doReadNumber(double* number)
-    {
-        if (m_position + sizeof(double) > m_length)
-            return false;
-        uint8_t* numberAsByteArray = reinterpret_cast<uint8_t*>(number);
-        for (unsigned i = 0; i < sizeof(double); ++i)
-            numberAsByteArray[i] = m_buffer[m_position++];
-        return true;
-    }
-
-    const uint8_t* m_buffer;
+    const char* m_buffer;
     const unsigned m_length;
     unsigned m_position;
 };
 
-class Deserializer : public CompositeCreator {
+class Deserializer {
 public:
-    explicit Deserializer(Reader& reader)
-        : m_reader(reader)
+    explicit Deserializer(Reader& reader) : m_reader(reader)
     {
     }
@@ -791 +603 @@
     }
 
-    virtual bool createArray(uint32_t length, v8::Handle<v8::Value>* value)
-    {
-        if (length > stackDepth())
-            return false;
-        v8::Local<v8::Array> array = v8::Array::New(length);
-        if (array.IsEmpty())
-            return false;
-        const int depth = stackDepth() - length;
-        for (unsigned i = 0; i < length; ++i)
-            array->Set(i, element(depth + i));
-        pop(length);
-        *value = array;
-        return true;
-    }
-
-    virtual bool createObject(uint32_t numProperties, v8::Handle<v8::Value>* value)
-    {
-        v8::Local<v8::Object> object = v8::Object::New();
-        if (object.IsEmpty())
-            return false;
-        return initializeObject(object, numProperties, value);
-    }
-
-    virtual bool createSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
-    {
-        v8::Local<v8::Array> array = v8::Array::New(length);
-        if (array.IsEmpty())
-            return false;
-        return initializeObject(array, numProperties, value);
-    }
-
 private:
-    bool initializeObject(v8::Handle<v8::Object> object, uint32_t numProperties, v8::Handle<v8::Value>* value)
-    {
-        unsigned length = 2 * numProperties;
-        if (length > stackDepth())
-            return false;
-        for (unsigned i = stackDepth() - length; i < stackDepth(); i += 2) {
-            v8::Local<v8::Value> propertyName = element(i);
-            v8::Local<v8::Value> propertyValue = element(i + 1);
-            object->Set(propertyName, propertyValue);
-        }
-        pop(length);
-        *value = object;
-        return true;
-    }
-
     bool doDeserialize()
     {
+        SerializationTag tag;
         v8::Local<v8::Value> value;
-        if (!m_reader.read(&value, *this))
-            return false;
-        if (!value.IsEmpty())
+        int length = 0;
+        if (!m_reader.read(&tag, &value, &length))
+            return false;
+        if (!value.IsEmpty()) {
             push(value);
+        } else if (tag == ObjectTag) {
+            if (length > stackDepth())
+                return false;
+            v8::Local<v8::Object> object = v8::Object::New();
+            for (int i = stackDepth() - length; i < stackDepth(); i += 2) {
+                v8::Local<v8::Value> propertyName = element(i);
+                v8::Local<v8::Value> propertyValue = element(i + 1);
+                object->Set(propertyName, propertyValue);
+            }
+            pop(length);
+            push(object);
+        } else if (tag == ArrayTag) {
+            if (length > stackDepth())
+                return false;
+            v8::Local<v8::Array> array = v8::Array::New(length);
+            const int depth = stackDepth() - length;
+            {
+                v8::HandleScope scope;
+                for (int i = 0; i < length; ++i)
+                    array->Set(v8::Integer::New(i), element(depth + i));
+            }
+            pop(length);
+            push(array);
+        } else if (tag != PaddingTag)
+            return false;
         return true;
     }
@@ -856 +649 @@
     }
 
-    unsigned stackDepth() const { return m_stack.size(); }
+    int stackDepth() const { return m_stack.size(); }
 
     v8::Local<v8::Value> element(unsigned index)
@@ -899 +692 @@
         return v8::Null();
     COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
-    Reader reader(reinterpret_cast<const uint8_t*>(m_data.impl()->characters()), 2 * m_data.length());
+    Reader reader(reinterpret_cast<const char*>(m_data.impl()->characters()), 2 * m_data.length());
     Deserializer deserializer(reader);
     return deserializer.deserialize();