| /* |
| * 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 |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "SerializedScriptValue.h" |
| |
| #include "Blob.h" |
| #include "ByteArray.h" |
| #include "CanvasPixelArray.h" |
| #include "ExceptionCode.h" |
| #include "File.h" |
| #include "FileList.h" |
| #include "ImageData.h" |
| #include "SharedBuffer.h" |
| #include "V8Binding.h" |
| #include "V8Blob.h" |
| #include "V8File.h" |
| #include "V8FileList.h" |
| #include "V8ImageData.h" |
| #include "V8Proxy.h" |
| #include "V8Utilities.h" |
| |
| #include <wtf/Assertions.h> |
| #include <wtf/RefCounted.h> |
| #include <wtf/Vector.h> |
| |
| // FIXME: consider crashing in debug mode on deserialization errors |
| |
| namespace WebCore { |
| |
| namespace { |
| |
| typedef UChar BufferValueType; |
| |
| // Serialization format is a sequence of (tag, optional data) |
| // pairs. Tag always takes exactly one byte. |
| enum SerializationTag { |
| InvalidTag = '!', |
| PaddingTag = '\0', |
| UndefinedTag = '_', |
| NullTag = '0', |
| TrueTag = 'T', |
| FalseTag = 'F', |
| StringTag = 'S', |
| Int32Tag = 'I', |
| Uint32Tag = 'U', |
| DateTag = 'D', |
| NumberTag = 'N', |
| BlobTag = 'b', |
| FileTag = 'f', |
| FileListTag = 'l', |
| ImageDataTag = '#', |
| ArrayTag = '[', |
| ObjectTag = '{', |
| SparseArrayTag = '@', |
| RegExpTag = 'R', |
| }; |
| |
| static bool shouldCheckForCycles(int depth) |
| { |
| ASSERT(depth >= 0); |
| // Since we are not required to spot the cycle as soon as it |
| // happens we can check for cycles only when the current depth |
| // is a power of two. |
| return !(depth & (depth - 1)); |
| } |
| |
| static const int maxDepth = 20000; |
| |
| // VarInt encoding constants. |
| static const int varIntShift = 7; |
| static const int varIntMask = (1 << varIntShift) - 1; |
| |
| // ZigZag encoding helps VarInt encoding stay small for negative |
| // numbers with small absolute values. |
| class ZigZag { |
| public: |
| static uint32_t encode(uint32_t value) |
| { |
| if (value & (1U << 31)) |
| value = ((~value) << 1) + 1; |
| else |
| value <<= 1; |
| return value; |
| } |
| |
| static uint32_t decode(uint32_t value) |
| { |
| if (value & 1) |
| value = ~(value >> 1); |
| else |
| value >>= 1; |
| return value; |
| } |
| |
| 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() |
| : m_position(0) |
| { |
| } |
| |
| // Write functions for primitive types. |
| |
| void writeUndefined() { append(UndefinedTag); } |
| |
| void writeNull() { append(NullTag); } |
| |
| void writeTrue() { append(TrueTag); } |
| |
| void writeFalse() { append(FalseTag); } |
| |
| void writeString(const char* data, int length) |
| { |
| ASSERT(length >= 0); |
| append(StringTag); |
| doWriteString(data, length); |
| } |
| |
| void writeWebCoreString(const String& string) |
| { |
| // Uses UTF8 encoding so we can read it back as either V8 or |
| // WebCore string. |
| append(StringTag); |
| doWriteWebCoreString(string); |
| } |
| |
| void writeInt32(int32_t value) |
| { |
| append(Int32Tag); |
| doWriteUint32(ZigZag::encode(static_cast<uint32_t>(value))); |
| } |
| |
| 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 writeBlob(const String& url, const String& type, unsigned long long size) |
| { |
| append(BlobTag); |
| doWriteWebCoreString(url); |
| doWriteWebCoreString(type); |
| doWriteUint64(size); |
| } |
| |
| void writeFile(const String& path, const String& url, const String& type) |
| { |
| append(FileTag); |
| doWriteWebCoreString(path); |
| doWriteWebCoreString(url); |
| doWriteWebCoreString(type); |
| } |
| |
| void writeFileList(const FileList& fileList) |
| { |
| append(FileListTag); |
| uint32_t length = fileList.length(); |
| doWriteUint32(length); |
| for (unsigned i = 0; i < length; ++i) { |
| doWriteWebCoreString(fileList.item(i)->path()); |
| doWriteWebCoreString(fileList.item(i)->url().string()); |
| doWriteWebCoreString(fileList.item(i)->type()); |
| } |
| } |
| |
| 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 writeRegExp(v8::Local<v8::String> pattern, v8::RegExp::Flags flags) |
| { |
| append(RegExpTag); |
| v8::String::Utf8Value patternUtf8Value(pattern); |
| doWriteString(*patternUtf8Value, patternUtf8Value.length()); |
| doWriteUint32(static_cast<uint32_t>(flags)); |
| } |
| |
| 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); |
| } |
| |
| Vector<BufferValueType>& data() |
| { |
| fillHole(); |
| return m_buffer; |
| } |
| |
| private: |
| void doWriteString(const char* data, int length) |
| { |
| doWriteUint32(static_cast<uint32_t>(length)); |
| append(reinterpret_cast<const uint8_t*>(data), length); |
| } |
| |
| void doWriteWebCoreString(const String& string) |
| { |
| RefPtr<SharedBuffer> buffer = utf8Buffer(string); |
| doWriteString(buffer->data(), buffer->size()); |
| } |
| |
| template<class T> |
| void doWriteUintHelper(T value) |
| { |
| while (true) { |
| uint8_t b = (value & varIntMask); |
| value >>= varIntShift; |
| if (!value) { |
| append(b); |
| break; |
| } |
| append(b | (1 << varIntShift)); |
| } |
| } |
| |
| void doWriteUint32(uint32_t value) |
| { |
| doWriteUintHelper(value); |
| } |
| |
| void doWriteUint64(uint64_t value) |
| { |
| doWriteUintHelper(value); |
| } |
| |
| 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) |
| { |
| ensureSpace(1); |
| *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) |
| { |
| COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes); |
| m_buffer.grow((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; } |
| |
| Vector<BufferValueType> m_buffer; |
| unsigned m_position; |
| }; |
| |
| class Serializer { |
| class StateBase; |
| public: |
| enum Status { |
| Success, |
| InputError, |
| JSException, |
| JSFailure |
| }; |
| |
| Serializer(Writer& writer, v8::TryCatch& tryCatch) |
| : m_writer(writer) |
| , m_tryCatch(tryCatch) |
| , m_depth(0) |
| , m_status(Success) |
| { |
| ASSERT(!tryCatch.HasCaught()); |
| } |
| |
| Status serialize(v8::Handle<v8::Value> value) |
| { |
| v8::HandleScope scope; |
| StateBase* state = doSerialize(value, 0); |
| while (state) |
| state = state->advance(*this); |
| return m_status; |
| } |
| |
| // Functions used by serialization states. |
| |
| StateBase* doSerialize(v8::Handle<v8::Value> value, StateBase* next); |
| |
| StateBase* checkException(StateBase* state) |
| { |
| return m_tryCatch.HasCaught() ? handleError(JSException, state) : 0; |
| } |
| |
| StateBase* reportFailure(StateBase* state) |
| { |
| return handleError(JSFailure, state); |
| } |
| |
| 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); |
| } |
| |
| private: |
| class StateBase { |
| WTF_MAKE_NONCOPYABLE(StateBase); |
| public: |
| virtual ~StateBase() { } |
| |
| // Link to the next state to form a stack. |
| StateBase* nextState() { return m_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; |
| |
| protected: |
| StateBase(v8::Handle<v8::Value> composite, StateBase* next) |
| : m_composite(composite) |
| , m_next(next) |
| { |
| } |
| |
| private: |
| 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> |
| class State : public StateBase { |
| public: |
| v8::Handle<T> composite() { return v8::Handle<T>::Cast(StateBase::composite()); } |
| |
| protected: |
| State(v8::Handle<T> composite, StateBase* next) |
| : StateBase(composite, next) |
| { |
| } |
| }; |
| |
| #if 0 |
| // Currently unused, see comment in newArrayState. |
| class ArrayState : public State<v8::Array> { |
| 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) { |
| v8::Handle<v8::Value> value = composite()->Get(m_index); |
| if (StateBase* newState = serializer.checkException(this)) |
| return newState; |
| if (StateBase* newState = serializer.doSerialize(value, this)) |
| return newState; |
| } |
| return serializer.writeArray(composite()->Length(), this); |
| } |
| |
| private: |
| unsigned m_index; |
| }; |
| #endif |
| |
| class AbstractObjectState : public State<v8::Object> { |
| public: |
| AbstractObjectState(v8::Handle<v8::Object> object, StateBase* next) |
| : State<v8::Object>(object, next) |
| , m_index(0) |
| , m_numSerializedProperties(0) |
| , m_nameDone(false) |
| { |
| } |
| |
| virtual StateBase* advance(Serializer& serializer) |
| { |
| if (!m_index) { |
| m_propertyNames = composite()->GetPropertyNames(); |
| if (StateBase* newState = serializer.checkException(this)) |
| return newState; |
| if (m_propertyNames.IsEmpty()) |
| return serializer.reportFailure(this); |
| } |
| while (m_index < m_propertyNames->Length()) { |
| if (!m_nameDone) { |
| v8::Local<v8::Value> propertyName = m_propertyNames->Get(m_index); |
| if (StateBase* newState = serializer.checkException(this)) |
| return newState; |
| if (propertyName.IsEmpty()) |
| return serializer.reportFailure(this); |
| bool hasStringProperty = propertyName->IsString() && composite()->HasRealNamedProperty(propertyName.As<v8::String>()); |
| if (StateBase* newState = serializer.checkException(this)) |
| return newState; |
| bool hasIndexedProperty = !hasStringProperty && propertyName->IsUint32() && composite()->HasRealIndexedProperty(propertyName->Uint32Value()); |
| if (StateBase* newState = serializer.checkException(this)) |
| return newState; |
| if (hasStringProperty || hasIndexedProperty) |
| m_propertyName = propertyName; |
| else { |
| ++m_index; |
| continue; |
| } |
| } |
| 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); |
| if (StateBase* newState = serializer.checkException(this)) |
| return newState; |
| m_nameDone = false; |
| m_propertyName.Clear(); |
| ++m_index; |
| ++m_numSerializedProperties; |
| if (StateBase* newState = serializer.doSerialize(value, this)) |
| return newState; |
| } |
| return objectDone(m_numSerializedProperties, 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; |
| unsigned m_numSerializedProperties; |
| bool m_nameDone; |
| }; |
| |
| 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); |
| ++m_depth; |
| return checkComposite(state) ? state : handleError(InputError, state); |
| } |
| |
| StateBase* pop(StateBase* state) |
| { |
| ASSERT(state); |
| --m_depth; |
| StateBase* next = state->nextState(); |
| delete state; |
| return next; |
| } |
| |
| StateBase* handleError(Status errorStatus, StateBase* state) |
| { |
| ASSERT(errorStatus != Success); |
| m_status = errorStatus; |
| while (state) { |
| StateBase* tmp = state->nextState(); |
| delete state; |
| state = tmp; |
| } |
| return new ErrorState; |
| } |
| |
| bool checkComposite(StateBase* top) |
| { |
| ASSERT(top); |
| 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()) { |
| if (state->composite() == composite) |
| return false; |
| } |
| return true; |
| } |
| |
| void writeString(v8::Handle<v8::Value> value) |
| { |
| v8::String::Utf8Value stringValue(value); |
| m_writer.writeString(*stringValue, stringValue.length()); |
| } |
| |
| void writeBlob(v8::Handle<v8::Value> value) |
| { |
| Blob* blob = V8Blob::toNative(value.As<v8::Object>()); |
| if (!blob) |
| return; |
| m_writer.writeBlob(blob->url().string(), blob->type(), blob->size()); |
| } |
| |
| void writeFile(v8::Handle<v8::Value> value) |
| { |
| File* file = V8File::toNative(value.As<v8::Object>()); |
| if (!file) |
| return; |
| m_writer.writeFile(file->path(), file->url().string(), file->type()); |
| } |
| |
| void writeFileList(v8::Handle<v8::Value> value) |
| { |
| FileList* fileList = V8FileList::toNative(value.As<v8::Object>()); |
| if (!fileList) |
| return; |
| m_writer.writeFileList(*fileList); |
| } |
| |
| 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()); |
| } |
| |
| void writeRegExp(v8::Handle<v8::Value> value) |
| { |
| v8::Handle<v8::RegExp> regExp = value.As<v8::RegExp>(); |
| m_writer.writeRegExp(regExp->GetSource(), regExp->GetFlags()); |
| } |
| |
| 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 |
| return new ObjectState(object, next); |
| } |
| |
| Writer& m_writer; |
| v8::TryCatch& m_tryCatch; |
| int m_depth; |
| Status m_status; |
| }; |
| |
| Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, StateBase* next) |
| { |
| if (value.IsEmpty()) |
| return reportFailure(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 (V8File::HasInstance(value)) |
| writeFile(value); |
| else if (V8Blob::HasInstance(value)) |
| writeBlob(value); |
| else if (V8FileList::HasInstance(value)) |
| writeFileList(value); |
| else if (V8ImageData::HasInstance(value)) |
| writeImageData(value); |
| else if (value->IsRegExp()) |
| writeRegExp(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; |
| }; |
| |
| // Reader is responsible for deserializing primitive types and |
| // restoring information about saved objects of composite types. |
| class Reader { |
| public: |
| Reader(const uint8_t* buffer, int length) |
| : m_buffer(buffer) |
| , m_length(length) |
| , m_position(0) |
| { |
| ASSERT(length >= 0); |
| } |
| |
| 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) { |
| case InvalidTag: |
| return false; |
| case PaddingTag: |
| return true; |
| case UndefinedTag: |
| *value = v8::Undefined(); |
| break; |
| case NullTag: |
| *value = v8::Null(); |
| break; |
| case TrueTag: |
| *value = v8::True(); |
| break; |
| case FalseTag: |
| *value = v8::False(); |
| break; |
| case StringTag: |
| if (!readString(value)) |
| return false; |
| break; |
| case Int32Tag: |
| if (!readInt32(value)) |
| 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 BlobTag: |
| if (!readBlob(value)) |
| return false; |
| break; |
| case FileTag: |
| if (!readFile(value)) |
| return false; |
| break; |
| case FileListTag: |
| if (!readFileList(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 RegExpTag: |
| if (!readRegExp(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(); |
| } |
| |
| private: |
| bool readTag(SerializationTag* tag) |
| { |
| if (m_position >= m_length) |
| return false; |
| *tag = static_cast<SerializationTag>(m_buffer[m_position++]); |
| return true; |
| } |
| |
| bool readString(v8::Handle<v8::Value>* value) |
| { |
| uint32_t length; |
| if (!doReadUint32(&length)) |
| return false; |
| if (m_position + length > m_length) |
| return false; |
| *value = v8::String::New(reinterpret_cast<const char*>(m_buffer + m_position), length); |
| m_position += length; |
| return true; |
| } |
| |
| bool readWebCoreString(String* string) |
| { |
| uint32_t length; |
| if (!doReadUint32(&length)) |
| return false; |
| if (m_position + length > m_length) |
| return false; |
| *string = String::fromUTF8(reinterpret_cast<const char*>(m_buffer + m_position), length); |
| m_position += length; |
| return true; |
| } |
| |
| bool readInt32(v8::Handle<v8::Value>* value) |
| { |
| uint32_t rawValue; |
| if (!doReadUint32(&rawValue)) |
| return false; |
| *value = v8::Integer::New(static_cast<int32_t>(ZigZag::decode(rawValue))); |
| return true; |
| } |
| |
| bool readUint32(v8::Handle<v8::Value>* value) |
| { |
| uint32_t rawValue; |
| if (!doReadUint32(&rawValue)) |
| return false; |
| *value = v8::Integer::NewFromUnsigned(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) |
| { |
| double number; |
| if (!doReadNumber(&number)) |
| return false; |
| *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; |
| RefPtr<ImageData> imageData = ImageData::create(IntSize(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.release()); |
| return true; |
| } |
| |
| bool readRegExp(v8::Handle<v8::Value>* value) |
| { |
| v8::Handle<v8::Value> pattern; |
| if (!readString(&pattern)) |
| return false; |
| uint32_t flags; |
| if (!doReadUint32(&flags)) |
| return false; |
| *value = v8::RegExp::New(pattern.As<v8::String>(), static_cast<v8::RegExp::Flags>(flags)); |
| return true; |
| } |
| |
| bool readBlob(v8::Handle<v8::Value>* value) |
| { |
| String url; |
| String type; |
| uint64_t size; |
| if (!readWebCoreString(&url)) |
| return false; |
| if (!readWebCoreString(&type)) |
| return false; |
| if (!doReadUint64(&size)) |
| return false; |
| PassRefPtr<Blob> blob = Blob::create(KURL(ParsedURLString, url), type, size); |
| *value = toV8(blob); |
| return true; |
| } |
| |
| bool readFile(v8::Handle<v8::Value>* value) |
| { |
| String path; |
| String url; |
| String type; |
| if (!readWebCoreString(&path)) |
| return false; |
| if (!readWebCoreString(&url)) |
| return false; |
| if (!readWebCoreString(&type)) |
| return false; |
| PassRefPtr<File> file = File::create(path, KURL(ParsedURLString, url), type); |
| *value = toV8(file); |
| return true; |
| } |
| |
| bool readFileList(v8::Handle<v8::Value>* value) |
| { |
| uint32_t length; |
| if (!doReadUint32(&length)) |
| return false; |
| PassRefPtr<FileList> fileList = FileList::create(); |
| for (unsigned i = 0; i < length; ++i) { |
| String path; |
| String urlString; |
| String type; |
| if (!readWebCoreString(&path)) |
| return false; |
| if (!readWebCoreString(&urlString)) |
| return false; |
| if (!readWebCoreString(&type)) |
| return false; |
| fileList->append(File::create(path, KURL(ParsedURLString, urlString), type)); |
| } |
| *value = toV8(fileList); |
| return true; |
| } |
| |
| template<class T> |
| bool doReadUintHelper(T* value) |
| { |
| *value = 0; |
| uint8_t currentByte; |
| int shift = 0; |
| do { |
| if (m_position >= m_length) |
| return false; |
| currentByte = m_buffer[m_position++]; |
| *value |= ((currentByte & varIntMask) << shift); |
| shift += varIntShift; |
| } while (currentByte & (1 << varIntShift)); |
| return true; |
| } |
| |
| bool doReadUint32(uint32_t* value) |
| { |
| return doReadUintHelper(value); |
| } |
| |
| bool doReadUint64(uint64_t* value) |
| { |
| return doReadUintHelper(value); |
| } |
| |
| 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 unsigned m_length; |
| unsigned m_position; |
| }; |
| |
| class Deserializer : public CompositeCreator { |
| public: |
| explicit Deserializer(Reader& reader) |
| : m_reader(reader) |
| { |
| } |
| |
| v8::Handle<v8::Value> deserialize() |
| { |
| v8::HandleScope scope; |
| while (!m_reader.isEof()) { |
| if (!doDeserialize()) |
| return v8::Null(); |
| } |
| if (stackDepth() != 1) |
| return v8::Null(); |
| return scope.Close(element(0)); |
| } |
| |
| 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() |
| { |
| v8::Local<v8::Value> value; |
| if (!m_reader.read(&value, *this)) |
| return false; |
| if (!value.IsEmpty()) |
| push(value); |
| return true; |
| } |
| |
| void push(v8::Local<v8::Value> value) { m_stack.append(value); } |
| |
| void pop(unsigned length) |
| { |
| ASSERT(length <= m_stack.size()); |
| m_stack.shrink(m_stack.size() - length); |
| } |
| |
| unsigned stackDepth() const { return m_stack.size(); } |
| |
| v8::Local<v8::Value> element(unsigned index) |
| { |
| ASSERT(index < m_stack.size()); |
| return m_stack[index]; |
| } |
| |
| Reader& m_reader; |
| Vector<v8::Local<v8::Value> > m_stack; |
| }; |
| |
| } // namespace |
| |
| void SerializedScriptValue::deserializeAndSetProperty(v8::Handle<v8::Object> object, const char* propertyName, |
| v8::PropertyAttribute attribute, SerializedScriptValue* value) |
| { |
| if (!value) |
| return; |
| v8::Handle<v8::Value> deserialized = value->deserialize(); |
| object->ForceSet(v8::String::NewSymbol(propertyName), deserialized, attribute); |
| } |
| |
| void SerializedScriptValue::deserializeAndSetProperty(v8::Handle<v8::Object> object, const char* propertyName, |
| v8::PropertyAttribute attribute, PassRefPtr<SerializedScriptValue> value) |
| { |
| deserializeAndSetProperty(object, propertyName, attribute, value.get()); |
| } |
| |
| PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value, bool& didThrow) |
| { |
| return adoptRef(new SerializedScriptValue(value, didThrow)); |
| } |
| |
| PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value) |
| { |
| bool didThrow; |
| return adoptRef(new SerializedScriptValue(value, didThrow)); |
| } |
| |
| PassRefPtr<SerializedScriptValue> SerializedScriptValue::createFromWire(String data) |
| { |
| return adoptRef(new SerializedScriptValue(data)); |
| } |
| |
| PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(String data) |
| { |
| Writer writer; |
| writer.writeWebCoreString(data); |
| String wireData = StringImpl::adopt(writer.data()); |
| return adoptRef(new SerializedScriptValue(wireData)); |
| } |
| |
| PassRefPtr<SerializedScriptValue> SerializedScriptValue::create() |
| { |
| return adoptRef(new SerializedScriptValue()); |
| } |
| |
| SerializedScriptValue* SerializedScriptValue::nullValue() |
| { |
| DEFINE_STATIC_LOCAL(RefPtr<SerializedScriptValue>, nullValue, (0)); |
| if (!nullValue) { |
| Writer writer; |
| writer.writeNull(); |
| String wireData = StringImpl::adopt(writer.data()); |
| nullValue = adoptRef(new SerializedScriptValue(wireData)); |
| } |
| return nullValue.get(); |
| } |
| |
| SerializedScriptValue* SerializedScriptValue::undefinedValue() |
| { |
| DEFINE_STATIC_LOCAL(RefPtr<SerializedScriptValue>, undefinedValue, (0)); |
| if (!undefinedValue) { |
| Writer writer; |
| writer.writeUndefined(); |
| String wireData = StringImpl::adopt(writer.data()); |
| undefinedValue = adoptRef(new SerializedScriptValue(wireData)); |
| } |
| return undefinedValue.get(); |
| } |
| |
| PassRefPtr<SerializedScriptValue> SerializedScriptValue::release() |
| { |
| RefPtr<SerializedScriptValue> result = adoptRef(new SerializedScriptValue(m_data)); |
| m_data = String().crossThreadString(); |
| return result.release(); |
| } |
| |
| SerializedScriptValue::SerializedScriptValue() |
| { |
| } |
| |
| SerializedScriptValue::SerializedScriptValue(v8::Handle<v8::Value> value, bool& didThrow) |
| { |
| didThrow = false; |
| Writer writer; |
| Serializer::Status status; |
| { |
| v8::TryCatch tryCatch; |
| Serializer serializer(writer, tryCatch); |
| status = serializer.serialize(value); |
| if (status == Serializer::JSException) { |
| // If there was a JS exception thrown, re-throw it. |
| didThrow = true; |
| tryCatch.ReThrow(); |
| return; |
| } |
| } |
| if (status == Serializer::InputError) { |
| // If there was an input error, throw a new exception outside |
| // of the TryCatch scope. |
| didThrow = true; |
| throwError(NOT_SUPPORTED_ERR); |
| return; |
| } |
| if (status == 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; |
| } |
| ASSERT(status == Serializer::Success); |
| m_data = String(StringImpl::adopt(writer.data())).crossThreadString(); |
| } |
| |
| SerializedScriptValue::SerializedScriptValue(String wireData) |
| { |
| m_data = wireData.crossThreadString(); |
| } |
| |
| v8::Handle<v8::Value> SerializedScriptValue::deserialize() |
| { |
| if (!m_data.impl()) |
| return v8::Null(); |
| COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes); |
| Reader reader(reinterpret_cast<const uint8_t*>(m_data.impl()->characters()), 2 * m_data.length()); |
| Deserializer deserializer(reader); |
| return deserializer.deserialize(); |
| } |
| |
| } // namespace WebCore |
