bindings: fixed incorrect dependency of SerializedScriptValue.

Source/bindings/core/v8/ScriptValueSerializer.cpp

Index: Source/bindings/core/v8/ScriptValueSerializer.cpp
diff --git a/Source/bindings/core/v8/ScriptValueSerializer.cpp b/Source/bindings/core/v8/ScriptValueSerializer.cpp
index 38455c8c93d06ea54e9ab0d119fd143cc6da7331..cd783a0fce5afe4e98370fdcf6686ea1d3cc8ea3 100644
--- a/Source/bindings/core/v8/ScriptValueSerializer.cpp
+++ b/Source/bindings/core/v8/ScriptValueSerializer.cpp
@@ -12,8 +12,6 @@
 #include "bindings/core/v8/V8FileList.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
-#include "bindings/modules/v8/V8CryptoKey.h"
-#include "bindings/modules/v8/V8DOMFileSystem.h"
 #include "core/dom/DOMDataView.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
@@ -31,8 +29,6 @@
 
 namespace blink {
 
-namespace SerializedScriptValueInternal {
-
 // This code implements the HTML5 Structured Clone algorithm:
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/urls.html#safe-passing-of-structured-data
 
@@ -73,32 +69,32 @@ static bool shouldCheckForCycles(int depth)
     return !(depth & (depth - 1));
 }
 
-void Writer::writeUndefined()
+void SerializedScriptValueWriter::writeUndefined()
 {
     append(UndefinedTag);
 }
 
-void Writer::writeNull()
+void SerializedScriptValueWriter::writeNull()
 {
     append(NullTag);
 }
 
-void Writer::writeTrue()
+void SerializedScriptValueWriter::writeTrue()
 {
     append(TrueTag);
 }
 
-void Writer::writeFalse()
+void SerializedScriptValueWriter::writeFalse()
 {
     append(FalseTag);
 }
 
-void Writer::writeBooleanObject(bool value)
+void SerializedScriptValueWriter::writeBooleanObject(bool value)
 {
     append(value ? TrueObjectTag : FalseObjectTag);
 }
 
-void Writer::writeOneByteString(v8::Handle<v8::String>& string)
+void SerializedScriptValueWriter::writeOneByteString(v8::Handle<v8::String>& string)
 {
     int stringLength = string->Length();
     int utf8Length = string->Utf8Length();
@@ -118,7 +114,7 @@ void Writer::writeOneByteString(v8::Handle<v8::String>& string)
     m_position += utf8Length;
 }
 
-void Writer::writeUCharString(v8::Handle<v8::String>& string)
+void SerializedScriptValueWriter::writeUCharString(v8::Handle<v8::String>& string)
 {
     int length = string->Length();
     ASSERT(length >= 0);
@@ -138,14 +134,14 @@ void Writer::writeUCharString(v8::Handle<v8::String>& string)
     m_position += size;
 }
 
-void Writer::writeStringObject(const char* data, int length)
+void SerializedScriptValueWriter::writeStringObject(const char* data, int length)
 {
     ASSERT(length >= 0);
     append(StringObjectTag);
     doWriteString(data, length);
 }
 
-void Writer::writeWebCoreString(const String& string)
+void SerializedScriptValueWriter::writeWebCoreString(const String& string)
 {
     // Uses UTF8 encoding so we can read it back as either V8 or
     // WebCore string.
@@ -153,43 +149,43 @@ void Writer::writeWebCoreString(const String& string)
     doWriteWebCoreString(string);
 }
 
-void Writer::writeVersion()
+void SerializedScriptValueWriter::writeVersion()
 {
     append(VersionTag);
     doWriteUint32(SerializedScriptValue::wireFormatVersion);
 }
 
-void Writer::writeInt32(int32_t value)
+void SerializedScriptValueWriter::writeInt32(int32_t value)
 {
     append(Int32Tag);
     doWriteUint32(ZigZag::encode(static_cast<uint32_t>(value)));
 }
 
-void Writer::writeUint32(uint32_t value)
+void SerializedScriptValueWriter::writeUint32(uint32_t value)
 {
     append(Uint32Tag);
     doWriteUint32(value);
 }
 
-void Writer::writeDate(double numberValue)
+void SerializedScriptValueWriter::writeDate(double numberValue)
 {
     append(DateTag);
     doWriteNumber(numberValue);
 }
 
-void Writer::writeNumber(double number)
+void SerializedScriptValueWriter::writeNumber(double number)
 {
     append(NumberTag);
     doWriteNumber(number);
 }
 
-void Writer::writeNumberObject(double number)
+void SerializedScriptValueWriter::writeNumberObject(double number)
 {
     append(NumberObjectTag);
     doWriteNumber(number);
 }
 
-void Writer::writeBlob(const String& uuid, const String& type, unsigned long long size)
+void SerializedScriptValueWriter::writeBlob(const String& uuid, const String& type, unsigned long long size)
 {
     append(BlobTag);
     doWriteWebCoreString(uuid);
@@ -197,34 +193,26 @@ void Writer::writeBlob(const String& uuid, const String& type, unsigned long lon
     doWriteUint64(size);
 }
 
-void Writer::writeDOMFileSystem(int type, const String& name, const String& url)
-{
-    append(DOMFileSystemTag);
-    doWriteUint32(type);
-    doWriteWebCoreString(name);
-    doWriteWebCoreString(url);
-}
-
-void Writer::writeBlobIndex(int blobIndex)
+void SerializedScriptValueWriter::writeBlobIndex(int blobIndex)
 {
     ASSERT(blobIndex >= 0);
     append(BlobIndexTag);
     doWriteUint32(blobIndex);
 }
 
-void Writer::writeFile(const File& file)
+void SerializedScriptValueWriter::writeFile(const File& file)
 {
     append(FileTag);
     doWriteFile(file);
 }
 
-void Writer::writeFileIndex(int blobIndex)
+void SerializedScriptValueWriter::writeFileIndex(int blobIndex)
 {
     append(FileIndexTag);
     doWriteUint32(blobIndex);
 }
 
-void Writer::writeFileList(const FileList& fileList)
+void SerializedScriptValueWriter::writeFileList(const FileList& fileList)
 {
     append(FileListTag);
     uint32_t length = fileList.length();
@@ -233,7 +221,7 @@ void Writer::writeFileList(const FileList& fileList)
         doWriteFile(*fileList.item(i));
 }
 
-void Writer::writeFileListIndex(const Vector<int>& blobIndices)
+void SerializedScriptValueWriter::writeFileListIndex(const Vector<int>& blobIndices)
 {
     append(FileListIndexTag);
     uint32_t length = blobIndices.size();
@@ -242,46 +230,13 @@ void Writer::writeFileListIndex(const Vector<int>& blobIndices)
         doWriteUint32(blobIndices[i]);
 }
 
-bool Writer::writeCryptoKey(const WebCryptoKey& key)
-{
-    append(static_cast<uint8_t>(CryptoKeyTag));
-
-    switch (key.algorithm().paramsType()) {
-    case WebCryptoKeyAlgorithmParamsTypeAes:
-        doWriteAesKey(key);
-        break;
-    case WebCryptoKeyAlgorithmParamsTypeHmac:
-        doWriteHmacKey(key);
-        break;
-    case WebCryptoKeyAlgorithmParamsTypeRsaHashed:
-        doWriteRsaHashedKey(key);
-        break;
-    case WebCryptoKeyAlgorithmParamsTypeEc:
-        doWriteEcKey(key);
-        break;
-    case WebCryptoKeyAlgorithmParamsTypeNone:
-        ASSERT_NOT_REACHED();
-        return false;
-    }
-
-    doWriteKeyUsages(key.usages(), key.extractable());
-
-    WebVector<uint8_t> keyData;
-    if (!Platform::current()->crypto()->serializeKeyForClone(key, keyData))
-        return false;
-
-    doWriteUint32(keyData.size());
-    append(keyData.data(), keyData.size());
-    return true;
-}
-
-void Writer::writeArrayBuffer(const ArrayBuffer& arrayBuffer)
+void SerializedScriptValueWriter::writeArrayBuffer(const ArrayBuffer& arrayBuffer)
 {
     append(ArrayBufferTag);
     doWriteArrayBuffer(arrayBuffer);
 }
 
-void Writer::writeArrayBufferView(const ArrayBufferView& arrayBufferView)
+void SerializedScriptValueWriter::writeArrayBufferView(const ArrayBufferView& arrayBufferView)
 {
     append(ArrayBufferViewTag);
 #if ENABLE(ASSERT)
@@ -317,7 +272,7 @@ void Writer::writeArrayBufferView(const ArrayBufferView& arrayBufferView)
     doWriteUint32(arrayBufferView.byteLength());
 }
 
-void Writer::writeImageData(uint32_t width, uint32_t height, const uint8_t* pixelData, uint32_t pixelDataLength)
+void SerializedScriptValueWriter::writeImageData(uint32_t width, uint32_t height, const uint8_t* pixelData, uint32_t pixelDataLength)
 {
     append(ImageDataTag);
     doWriteUint32(width);
@@ -326,7 +281,7 @@ void Writer::writeImageData(uint32_t width, uint32_t height, const uint8_t* pixe
     append(pixelData, pixelDataLength);
 }
 
-void Writer::writeRegExp(v8::Local<v8::String> pattern, v8::RegExp::Flags flags)
+void SerializedScriptValueWriter::writeRegExp(v8::Local<v8::String> pattern, v8::RegExp::Flags flags)
 {
     append(RegExpTag);
     v8::String::Utf8Value patternUtf8Value(pattern);
@@ -334,45 +289,45 @@ void Writer::writeRegExp(v8::Local<v8::String> pattern, v8::RegExp::Flags flags)
     doWriteUint32(static_cast<uint32_t>(flags));
 }
 
-void Writer::writeTransferredMessagePort(uint32_t index)
+void SerializedScriptValueWriter::writeTransferredMessagePort(uint32_t index)
 {
     append(MessagePortTag);
     doWriteUint32(index);
 }
 
-void Writer::writeTransferredArrayBuffer(uint32_t index)
+void SerializedScriptValueWriter::writeTransferredArrayBuffer(uint32_t index)
 {
     append(ArrayBufferTransferTag);
     doWriteUint32(index);
 }
 
-void Writer::writeObjectReference(uint32_t reference)
+void SerializedScriptValueWriter::writeObjectReference(uint32_t reference)
 {
     append(ObjectReferenceTag);
     doWriteUint32(reference);
 }
 
-void Writer::writeObject(uint32_t numProperties)
+void SerializedScriptValueWriter::writeObject(uint32_t numProperties)
 {
     append(ObjectTag);
     doWriteUint32(numProperties);
 }
 
-void Writer::writeSparseArray(uint32_t numProperties, uint32_t length)
+void SerializedScriptValueWriter::writeSparseArray(uint32_t numProperties, uint32_t length)
 {
     append(SparseArrayTag);
     doWriteUint32(numProperties);
     doWriteUint32(length);
 }
 
-void Writer::writeDenseArray(uint32_t numProperties, uint32_t length)
+void SerializedScriptValueWriter::writeDenseArray(uint32_t numProperties, uint32_t length)
 {
     append(DenseArrayTag);
     doWriteUint32(numProperties);
     doWriteUint32(length);
 }
 
-String Writer::takeWireString()
+String SerializedScriptValueWriter::takeWireString()
 {
     COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
     fillHole();
@@ -381,30 +336,30 @@ String Writer::takeWireString()
     return data;
 }
 
-void Writer::writeReferenceCount(uint32_t numberOfReferences)
+void SerializedScriptValueWriter::writeReferenceCount(uint32_t numberOfReferences)
 {
     append(ReferenceCountTag);
     doWriteUint32(numberOfReferences);
 }
 
-void Writer::writeGenerateFreshObject()
+void SerializedScriptValueWriter::writeGenerateFreshObject()
 {
     append(GenerateFreshObjectTag);
 }
 
-void Writer::writeGenerateFreshSparseArray(uint32_t length)
+void SerializedScriptValueWriter::writeGenerateFreshSparseArray(uint32_t length)
 {
     append(GenerateFreshSparseArrayTag);
     doWriteUint32(length);
 }
 
-void Writer::writeGenerateFreshDenseArray(uint32_t length)
+void SerializedScriptValueWriter::writeGenerateFreshDenseArray(uint32_t length)
 {
     append(GenerateFreshDenseArrayTag);
     doWriteUint32(length);
 }
 
-void Writer::doWriteFile(const File& file)
+void SerializedScriptValueWriter::doWriteFile(const File& file)
 {
     doWriteWebCoreString(file.hasBackingFile() ? file.path() : "");
     doWriteWebCoreString(file.name());
@@ -428,163 +383,26 @@ void Writer::doWriteFile(const File& file)
     doWriteUint32(static_cast<uint8_t>((file.userVisibility() == File::IsUserVisible) ? 1 : 0));
 }
 
-void Writer::doWriteArrayBuffer(const ArrayBuffer& arrayBuffer)
+void SerializedScriptValueWriter::doWriteArrayBuffer(const ArrayBuffer& arrayBuffer)
 {
     uint32_t byteLength = arrayBuffer.byteLength();
     doWriteUint32(byteLength);
     append(static_cast<const uint8_t*>(arrayBuffer.data()), byteLength);
 }
 
-void Writer::doWriteString(const char* data, int length)
+void SerializedScriptValueWriter::doWriteString(const char* data, int length)
 {
     doWriteUint32(static_cast<uint32_t>(length));
     append(reinterpret_cast<const uint8_t*>(data), length);
 }
 
-void Writer::doWriteWebCoreString(const String& string)
+void SerializedScriptValueWriter::doWriteWebCoreString(const String& string)
 {
     StringUTF8Adaptor stringUTF8(string);
     doWriteString(stringUTF8.data(), stringUTF8.length());
 }
 
-void Writer::doWriteHmacKey(const WebCryptoKey& key)
-{
-    ASSERT(key.algorithm().paramsType() == WebCryptoKeyAlgorithmParamsTypeHmac);
-
-    append(static_cast<uint8_t>(HmacKeyTag));
-    ASSERT(!(key.algorithm().hmacParams()->lengthBits() % 8));
-    doWriteUint32(key.algorithm().hmacParams()->lengthBits() / 8);
-    doWriteAlgorithmId(key.algorithm().hmacParams()->hash().id());
-}
-
-void Writer::doWriteAesKey(const WebCryptoKey& key)
-{
-    ASSERT(key.algorithm().paramsType() == WebCryptoKeyAlgorithmParamsTypeAes);
-
-    append(static_cast<uint8_t>(AesKeyTag));
-    doWriteAlgorithmId(key.algorithm().id());
-    // Converting the key length from bits to bytes is lossless and makes
-    // it fit in 1 byte.
-    ASSERT(!(key.algorithm().aesParams()->lengthBits() % 8));
-    doWriteUint32(key.algorithm().aesParams()->lengthBits() / 8);
-}
-
-void Writer::doWriteRsaHashedKey(const WebCryptoKey& key)
-{
-    ASSERT(key.algorithm().rsaHashedParams());
-    append(static_cast<uint8_t>(RsaHashedKeyTag));
-
-    doWriteAlgorithmId(key.algorithm().id());
-    doWriteAsymmetricKeyType(key.type());
-
-    const WebCryptoRsaHashedKeyAlgorithmParams* params = key.algorithm().rsaHashedParams();
-    doWriteUint32(params->modulusLengthBits());
-    doWriteUint32(params->publicExponent().size());
-    append(params->publicExponent().data(), params->publicExponent().size());
-    doWriteAlgorithmId(params->hash().id());
-}
-
-void Writer::doWriteEcKey(const WebCryptoKey& key)
-{
-    ASSERT(key.algorithm().ecParams());
-    append(static_cast<uint8_t>(EcKeyTag));
-
-    doWriteAlgorithmId(key.algorithm().id());
-    doWriteAsymmetricKeyType(key.type());
-    doWriteNamedCurve(key.algorithm().ecParams()->namedCurve());
-}
-
-void Writer::doWriteAlgorithmId(WebCryptoAlgorithmId id)
-{
-    switch (id) {
-    case WebCryptoAlgorithmIdAesCbc:
-        return doWriteUint32(AesCbcTag);
-    case WebCryptoAlgorithmIdHmac:
-        return doWriteUint32(HmacTag);
-    case WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
-        return doWriteUint32(RsaSsaPkcs1v1_5Tag);
-    case WebCryptoAlgorithmIdSha1:
-        return doWriteUint32(Sha1Tag);
-    case WebCryptoAlgorithmIdSha256:
-        return doWriteUint32(Sha256Tag);
-    case WebCryptoAlgorithmIdSha384:
-        return doWriteUint32(Sha384Tag);
-    case WebCryptoAlgorithmIdSha512:
-        return doWriteUint32(Sha512Tag);
-    case WebCryptoAlgorithmIdAesGcm:
-        return doWriteUint32(AesGcmTag);
-    case WebCryptoAlgorithmIdRsaOaep:
-        return doWriteUint32(RsaOaepTag);
-    case WebCryptoAlgorithmIdAesCtr:
-        return doWriteUint32(AesCtrTag);
-    case WebCryptoAlgorithmIdAesKw:
-        return doWriteUint32(AesKwTag);
-    case WebCryptoAlgorithmIdRsaPss:
-        return doWriteUint32(RsaPssTag);
-    case WebCryptoAlgorithmIdEcdsa:
-        return doWriteUint32(EcdsaTag);
-    }
-    ASSERT_NOT_REACHED();
-}
-
-void Writer::doWriteAsymmetricKeyType(WebCryptoKeyType keyType)
-{
-    switch (keyType) {
-    case WebCryptoKeyTypePublic:
-        doWriteUint32(PublicKeyType);
-        break;
-    case WebCryptoKeyTypePrivate:
-        doWriteUint32(PrivateKeyType);
-        break;
-    case WebCryptoKeyTypeSecret:
-        ASSERT_NOT_REACHED();
-    }
-}
-
-void Writer::doWriteNamedCurve(WebCryptoNamedCurve namedCurve)
-{
-    switch (namedCurve) {
-    case WebCryptoNamedCurveP256:
-        return doWriteUint32(P256Tag);
-    case WebCryptoNamedCurveP384:
-        return doWriteUint32(P384Tag);
-    case WebCryptoNamedCurveP521:
-        return doWriteUint32(P521Tag);
-    }
-    ASSERT_NOT_REACHED();
-}
-
-void Writer::doWriteKeyUsages(const WebCryptoKeyUsageMask usages, bool extractable)
-{
-    // Reminder to update this when adding new key usages.
-    COMPILE_ASSERT(EndOfWebCryptoKeyUsage == (1 << 7) + 1, UpdateMe);
-
-    uint32_t value = 0;
-
-    if (extractable)
-        value |= ExtractableUsage;
-
-    if (usages & WebCryptoKeyUsageEncrypt)
-        value |= EncryptUsage;
-    if (usages & WebCryptoKeyUsageDecrypt)
-        value |= DecryptUsage;
-    if (usages & WebCryptoKeyUsageSign)
-        value |= SignUsage;
-    if (usages & WebCryptoKeyUsageVerify)
-        value |= VerifyUsage;
-    if (usages & WebCryptoKeyUsageDeriveKey)
-        value |= DeriveKeyUsage;
-    if (usages & WebCryptoKeyUsageWrapKey)
-        value |= WrapKeyUsage;
-    if (usages & WebCryptoKeyUsageUnwrapKey)
-        value |= UnwrapKeyUsage;
-    if (usages & WebCryptoKeyUsageDeriveBits)
-        value |= DeriveBitsUsage;
-
-    doWriteUint32(value);
-}
-
-int Writer::bytesNeededToWireEncode(uint32_t value)
+int SerializedScriptValueWriter::bytesNeededToWireEncode(uint32_t value)
 {
     int bytes = 1;
     while (true) {
@@ -597,46 +415,46 @@ int Writer::bytesNeededToWireEncode(uint32_t value)
     return bytes;
 }
 
-void Writer::doWriteUint32(uint32_t value)
+void SerializedScriptValueWriter::doWriteUint32(uint32_t value)
 {
     doWriteUintHelper(value);
 }
 
-void Writer::doWriteUint64(uint64_t value)
+void SerializedScriptValueWriter::doWriteUint64(uint64_t value)
 {
     doWriteUintHelper(value);
 }
 
-void Writer::doWriteNumber(double number)
+void SerializedScriptValueWriter::doWriteNumber(double number)
 {
     append(reinterpret_cast<uint8_t*>(&number), sizeof(number));
 }
 
-void Writer::append(SerializationTag tag)
+void SerializedScriptValueWriter::append(SerializationTag tag)
 {
     append(static_cast<uint8_t>(tag));
 }
 
-void Writer::append(uint8_t b)
+void SerializedScriptValueWriter::append(uint8_t b)
 {
     ensureSpace(1);
     *byteAt(m_position++) = b;
 }
 
-void Writer::append(const uint8_t* data, int length)
+void SerializedScriptValueWriter::append(const uint8_t* data, int length)
 {
     ensureSpace(length);
     memcpy(byteAt(m_position), data, length);
     m_position += length;
 }
 
-void Writer::ensureSpace(unsigned extra)
+void SerializedScriptValueWriter::ensureSpace(unsigned extra)
 {
     COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
     m_buffer.resize((m_position + extra + 1) / sizeof(BufferValueType)); // "+ 1" to round up.
 }
 
-void Writer::fillHole()
+void SerializedScriptValueWriter::fillHole()
 {
     COMPILE_ASSERT(sizeof(BufferValueType) == 2, BufferValueTypeIsTwoBytes);
     // If the writer is at odd position in the buffer, then one of
@@ -645,17 +463,17 @@ void Writer::fillHole()
         *byteAt(m_position) = static_cast<uint8_t>(PaddingTag);
 }
 
-uint8_t* Writer::byteAt(int position)
+uint8_t* SerializedScriptValueWriter::byteAt(int position)
 {
     return reinterpret_cast<uint8_t*>(m_buffer.data()) + position;
 }
 
-int Writer::v8StringWriteOptions()
+int SerializedScriptValueWriter::v8StringWriteOptions()
 {
     return v8::String::NO_NULL_TERMINATION;
 }
 
-Serializer::StateBase* Serializer::AbstractObjectState::serializeProperties(bool ignoreIndexed, Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::AbstractObjectState::serializeProperties(bool ignoreIndexed, ScriptValueSerializer& serializer)
 {
     while (m_index < m_propertyNames->Length()) {
         if (!m_nameDone) {
@@ -699,7 +517,7 @@ Serializer::StateBase* Serializer::AbstractObjectState::serializeProperties(bool
     return objectDone(m_numSerializedProperties, serializer);
 }
 
-Serializer::StateBase* Serializer::ObjectState::advance(Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::ObjectState::advance(ScriptValueSerializer& serializer)
 {
     if (m_propertyNames.IsEmpty()) {
         m_propertyNames = composite()->GetPropertyNames();
@@ -711,12 +529,12 @@ Serializer::StateBase* Serializer::ObjectState::advance(Serializer& serializer)
     return serializeProperties(false, serializer);
 }
 
-Serializer::StateBase* Serializer::ObjectState::objectDone(unsigned numProperties, Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::ObjectState::objectDone(unsigned numProperties, ScriptValueSerializer& serializer)
 {
     return serializer.writeObject(numProperties, this);
 }
 
-Serializer::StateBase* Serializer::DenseArrayState::advance(Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::DenseArrayState::advance(ScriptValueSerializer& serializer)
 {
     while (m_arrayIndex < m_arrayLength) {
         v8::Handle<v8::Value> value = composite().As<v8::Array>()->Get(m_arrayIndex);
@@ -729,17 +547,17 @@ Serializer::StateBase* Serializer::DenseArrayState::advance(Serializer& serializ
     return serializeProperties(true, serializer);
 }
 
-Serializer::StateBase* Serializer::DenseArrayState::objectDone(unsigned numProperties, Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::DenseArrayState::objectDone(unsigned numProperties, ScriptValueSerializer& serializer)
 {
     return serializer.writeDenseArray(numProperties, m_arrayLength, this);
 }
 
-Serializer::StateBase* Serializer::SparseArrayState::advance(Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::SparseArrayState::advance(ScriptValueSerializer& serializer)
 {
     return serializeProperties(false, serializer);
 }
 
-Serializer::StateBase* Serializer::SparseArrayState::objectDone(unsigned numProperties, Serializer& serializer)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::SparseArrayState::objectDone(unsigned numProperties, ScriptValueSerializer& serializer)
 {
     return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
 }
@@ -773,7 +591,7 @@ static bool isHostObject(v8::Handle<v8::Object> object)
     return object->InternalFieldCount() || object->HasIndexedPropertiesInExternalArrayData();
 }
 
-Serializer::Serializer(Writer& writer, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
+ScriptValueSerializer::ScriptValueSerializer(SerializedScriptValueWriter& writer, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
     : m_scriptState(scriptState)
     , m_writer(writer)
     , m_tryCatch(tryCatch)
@@ -799,7 +617,7 @@ Serializer::Serializer(Writer& writer, MessagePortArray* messagePorts, ArrayBuff
     }
 }
 
-Serializer::Status Serializer::serialize(v8::Handle<v8::Value> value)
+ScriptValueSerializer::Status ScriptValueSerializer::serialize(v8::Handle<v8::Value> value)
 {
     v8::HandleScope scope(isolate());
     m_writer.writeVersion();
@@ -809,7 +627,7 @@ Serializer::Status Serializer::serialize(v8::Handle<v8::Value> value)
     return m_status;
 }
 
-Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::doSerialize(v8::Handle<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     m_writer.writeReferenceCount(m_nextObjectReference);
     uint32_t objectReference;
@@ -868,13 +686,8 @@ Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, Seri
             return writeFile(value, next);
         } else if (V8Blob::hasInstance(value, isolate())) {
             return writeBlob(value, next);
-        } else if (V8DOMFileSystem::hasInstance(value, isolate())) {
-            return writeDOMFileSystem(value, next);
         } else if (V8FileList::hasInstance(value, isolate())) {
             return writeFileList(value, next);
-        } else if (V8CryptoKey::hasInstance(value, isolate())) {
-            if (!writeCryptoKey(value))
-                return handleError(DataCloneError, "Couldn't serialize key data", next);
         } else if (V8ImageData::hasInstance(value, isolate())) {
             writeImageData(value);
         } else if (value->IsRegExp()) {
@@ -892,35 +705,35 @@ Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, Seri
     return 0;
 }
 
-Serializer::StateBase* Serializer::doSerializeArrayBuffer(v8::Handle<v8::Value> arrayBuffer, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::doSerializeArrayBuffer(v8::Handle<v8::Value> arrayBuffer, ScriptValueSerializer::StateBase* next)
 {
     return doSerialize(arrayBuffer, next);
 }
 
-Serializer::StateBase* Serializer::checkException(Serializer::StateBase* state)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::checkException(ScriptValueSerializer::StateBase* state)
 {
     return m_tryCatch.HasCaught() ? handleError(JSException, "", state) : 0;
 }
 
-Serializer::StateBase* Serializer::writeObject(uint32_t numProperties, Serializer::StateBase* state)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeObject(uint32_t numProperties, ScriptValueSerializer::StateBase* state)
 {
     m_writer.writeObject(numProperties);
     return pop(state);
 }
 
-Serializer::StateBase* Serializer::writeSparseArray(uint32_t numProperties, uint32_t length, Serializer::StateBase* state)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeSparseArray(uint32_t numProperties, uint32_t length, ScriptValueSerializer::StateBase* state)
 {
     m_writer.writeSparseArray(numProperties, length);
     return pop(state);
 }
 
-Serializer::StateBase* Serializer::writeDenseArray(uint32_t numProperties, uint32_t length, Serializer::StateBase* state)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeDenseArray(uint32_t numProperties, uint32_t length, ScriptValueSerializer::StateBase* state)
 {
     m_writer.writeDenseArray(numProperties, length);
     return pop(state);
 }
 
-Serializer::StateBase* Serializer::handleError(Serializer::Status errorStatus, const String& message, Serializer::StateBase* state)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::handleError(ScriptValueSerializer::Status errorStatus, const String& message, ScriptValueSerializer::StateBase* state)
 {
     ASSERT(errorStatus != Success);
     m_status = errorStatus;
@@ -933,7 +746,7 @@ Serializer::StateBase* Serializer::handleError(Serializer::Status errorStatus, c
     return new ErrorState;
 }
 
-bool Serializer::checkComposite(Serializer::StateBase* top)
+bool ScriptValueSerializer::checkComposite(ScriptValueSerializer::StateBase* top)
 {
     ASSERT(top);
     if (m_depth > maxDepth)
@@ -948,7 +761,7 @@ bool Serializer::checkComposite(Serializer::StateBase* top)
     return true;
 }
 
-void Serializer::writeString(v8::Handle<v8::Value> value)
+void ScriptValueSerializer::writeString(v8::Handle<v8::Value> value)
 {
     v8::Handle<v8::String> string = value.As<v8::String>();
     if (!string->Length() || string->IsOneByte())
@@ -957,26 +770,26 @@ void Serializer::writeString(v8::Handle<v8::Value> value)
         m_writer.writeUCharString(string);
 }
 
-void Serializer::writeStringObject(v8::Handle<v8::Value> value)
+void ScriptValueSerializer::writeStringObject(v8::Handle<v8::Value> value)
 {
     v8::Handle<v8::StringObject> stringObject = value.As<v8::StringObject>();
     v8::String::Utf8Value stringValue(stringObject->ValueOf());
     m_writer.writeStringObject(*stringValue, stringValue.length());
 }
 
-void Serializer::writeNumberObject(v8::Handle<v8::Value> value)
+void ScriptValueSerializer::writeNumberObject(v8::Handle<v8::Value> value)
 {
     v8::Handle<v8::NumberObject> numberObject = value.As<v8::NumberObject>();
     m_writer.writeNumberObject(numberObject->ValueOf());
 }
 
-void Serializer::writeBooleanObject(v8::Handle<v8::Value> value)
+void ScriptValueSerializer::writeBooleanObject(v8::Handle<v8::Value> value)
 {
     v8::Handle<v8::BooleanObject> booleanObject = value.As<v8::BooleanObject>();
     m_writer.writeBooleanObject(booleanObject->ValueOf());
 }
 
-Serializer::StateBase* Serializer::writeBlob(v8::Handle<v8::Value> value, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeBlob(v8::Handle<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     Blob* blob = V8Blob::toImpl(value.As<v8::Object>());
     if (!blob)
@@ -992,18 +805,7 @@ Serializer::StateBase* Serializer::writeBlob(v8::Handle<v8::Value> value, Serial
     return 0;
 }
 
-Serializer::StateBase* Serializer::writeDOMFileSystem(v8::Handle<v8::Value> value, StateBase* next)
-{
-    DOMFileSystem* fs = V8DOMFileSystem::toImpl(value.As<v8::Object>());
-    if (!fs)
-        return 0;
-    if (!fs->clonable())
-        return handleError(DataCloneError, "A FileSystem object could not be cloned.", next);
-    m_writer.writeDOMFileSystem(fs->type(), fs->name(), fs->rootURL().string());
-    return 0;
-}
-
-Serializer::StateBase* Serializer::writeFile(v8::Handle<v8::Value> value, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeFile(v8::Handle<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     File* file = V8File::toImpl(value.As<v8::Object>());
     if (!file)
@@ -1021,7 +823,7 @@ Serializer::StateBase* Serializer::writeFile(v8::Handle<v8::Value> value, Serial
     return 0;
 }
 
-Serializer::StateBase* Serializer::writeFileList(v8::Handle<v8::Value> value, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeFileList(v8::Handle<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     FileList* fileList = V8FileList::toImpl(value.As<v8::Object>());
     if (!fileList)
@@ -1047,15 +849,7 @@ Serializer::StateBase* Serializer::writeFileList(v8::Handle<v8::Value> value, Se
     return 0;
 }
 
-bool Serializer::writeCryptoKey(v8::Handle<v8::Value> value)
-{
-    CryptoKey* key = V8CryptoKey::toImpl(value.As<v8::Object>());
-    if (!key)
-        return false;
-    return m_writer.writeCryptoKey(key->key());
-}
-
-void Serializer::writeImageData(v8::Handle<v8::Value> value)
+void ScriptValueSerializer::writeImageData(v8::Handle<v8::Value> value)
 {
     ImageData* imageData = V8ImageData::toImpl(value.As<v8::Object>());
     if (!imageData)
@@ -1064,13 +858,13 @@ void Serializer::writeImageData(v8::Handle<v8::Value> value)
     m_writer.writeImageData(imageData->width(), imageData->height(), pixelArray->data(), pixelArray->length());
 }
 
-void Serializer::writeRegExp(v8::Handle<v8::Value> value)
+void ScriptValueSerializer::writeRegExp(v8::Handle<v8::Value> value)
 {
     v8::Handle<v8::RegExp> regExp = value.As<v8::RegExp>();
     m_writer.writeRegExp(regExp->GetSource(), regExp->GetFlags());
 }
 
-Serializer::StateBase* Serializer::writeAndGreyArrayBufferView(v8::Handle<v8::Object> object, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeAndGreyArrayBufferView(v8::Handle<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     ASSERT(!object.IsEmpty());
     DOMArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
@@ -1099,7 +893,7 @@ Serializer::StateBase* Serializer::writeAndGreyArrayBufferView(v8::Handle<v8::Ob
     return 0;
 }
 
-Serializer::StateBase* Serializer::writeArrayBuffer(v8::Handle<v8::Value> value, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeArrayBuffer(v8::Handle<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
     if (!arrayBuffer)
@@ -1111,7 +905,7 @@ Serializer::StateBase* Serializer::writeArrayBuffer(v8::Handle<v8::Value> value,
     return 0;
 }
 
-Serializer::StateBase* Serializer::writeTransferredArrayBuffer(v8::Handle<v8::Value> value, uint32_t index, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeTransferredArrayBuffer(v8::Handle<v8::Value> value, uint32_t index, ScriptValueSerializer::StateBase* next)
 {
     DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
     if (!arrayBuffer)
@@ -1122,7 +916,7 @@ Serializer::StateBase* Serializer::writeTransferredArrayBuffer(v8::Handle<v8::Va
     return 0;
 }
 
-bool Serializer::shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
+bool ScriptValueSerializer::shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
 {
     // Let K be the cost of serializing all property values that are there
     // Cost of serializing sparsely: 5*propertyCount + K (5 bytes per uint32_t key)
@@ -1131,7 +925,7 @@ bool Serializer::shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
     return 6 * propertyCount >= length;
 }
 
-Serializer::StateBase* Serializer::startArrayState(v8::Handle<v8::Array> array, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::startArrayState(v8::Handle<v8::Array> array, ScriptValueSerializer::StateBase* next)
 {
     v8::Handle<v8::Array> propertyNames = array->GetPropertyNames();
     if (StateBase* newState = checkException(next))
@@ -1147,7 +941,7 @@ Serializer::StateBase* Serializer::startArrayState(v8::Handle<v8::Array> array,
     return push(new SparseArrayState(array, propertyNames, next, isolate()));
 }
 
-Serializer::StateBase* Serializer::startObjectState(v8::Handle<v8::Object> object, Serializer::StateBase* next)
+ScriptValueSerializer::StateBase* ScriptValueSerializer::startObjectState(v8::Handle<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     m_writer.writeGenerateFreshObject();
     // FIXME: check not a wrapper
@@ -1156,14 +950,14 @@ Serializer::StateBase* Serializer::startObjectState(v8::Handle<v8::Object> objec
 
 // Marks object as having been visited by the serializer and assigns it a unique object reference ID.
 // An object may only be greyed once.
-void Serializer::greyObject(const v8::Handle<v8::Object>& object)
+void ScriptValueSerializer::greyObject(const v8::Handle<v8::Object>& object)
 {
     ASSERT(!m_objectPool.contains(object));
     uint32_t objectReference = m_nextObjectReference++;
     m_objectPool.set(object, objectReference);
 }
 
-bool Serializer::appendBlobInfo(const String& uuid, const String& type, unsigned long long size, int* index)
+bool ScriptValueSerializer::appendBlobInfo(const String& uuid, const String& type, unsigned long long size, int* index)
 {
     if (!m_blobInfo)
         return false;
@@ -1172,7 +966,7 @@ bool Serializer::appendBlobInfo(const String& uuid, const String& type, unsigned
     return true;
 }
 
-bool Serializer::appendFileInfo(const File* file, int* index)
+bool ScriptValueSerializer::appendFileInfo(const File* file, int* index)
 {
     if (!m_blobInfo)
         return false;
@@ -1185,11 +979,16 @@ bool Serializer::appendFileInfo(const File* file, int* index)
     return true;
 }
 
-bool Reader::read(v8::Handle<v8::Value>* value, CompositeCreator& creator)
+bool SerializedScriptValueReader::read(v8::Handle<v8::Value>* value, ScriptValueCompositeCreator& creator)
 {
     SerializationTag tag;
     if (!readTag(&tag))
         return false;
+    return readWithTag(tag, value, creator);
+}
+
+bool SerializedScriptValueReader::readWithTag(SerializationTag tag, v8::Handle<v8::Value>* value, ScriptValueCompositeCreator& creator)
+{
     switch (tag) {
     case ReferenceCountTag: {
         if (!m_version)
@@ -1275,22 +1074,12 @@ bool Reader::read(v8::Handle<v8::Value>* value, CompositeCreator& creator)
             return false;
         creator.pushObjectReference(*value);
         break;
-    case DOMFileSystemTag:
-        if (!readDOMFileSystem(value))
-            return false;
-        creator.pushObjectReference(*value);
-        break;
     case FileListTag:
     case FileListIndexTag:
         if (!readFileList(value, tag == FileListIndexTag))
             return false;
         creator.pushObjectReference(*value);
         break;
-    case CryptoKeyTag:
-        if (!readCryptoKey(value))
-            return false;
-        creator.pushObjectReference(*value);
-        break;
     case ImageDataTag:
         if (!readImageData(value))
             return false;
@@ -1405,13 +1194,16 @@ bool Reader::read(v8::Handle<v8::Value>* value, CompositeCreator& creator)
             return false;
         break;
     }
+    case DOMFileSystemTag:
+    case CryptoKeyTag:
+        ASSERT_NOT_REACHED();
     default:
         return false;
     }
     return !value->IsEmpty();
 }
 
-bool Reader::readVersion(uint32_t& version)
+bool SerializedScriptValueReader::readVersion(uint32_t& version)
 {
     SerializationTag tag;
     if (!readTag(&tag)) {
@@ -1430,12 +1222,12 @@ bool Reader::readVersion(uint32_t& version)
     return doReadUint32(&version);
 }
 
-void Reader::setVersion(uint32_t version)
+void SerializedScriptValueReader::setVersion(uint32_t version)
 {
     m_version = version;
 }
 
-bool Reader::readTag(SerializationTag* tag)
+bool SerializedScriptValueReader::readTag(SerializationTag* tag)
 {
     if (m_position >= m_length)
         return false;
@@ -1443,13 +1235,13 @@ bool Reader::readTag(SerializationTag* tag)
     return true;
 }
 
-void Reader::undoReadTag()
+void SerializedScriptValueReader::undoReadTag()
 {
     if (m_position > 0)
         --m_position;
 }
 
-bool Reader::readArrayBufferViewSubTag(ArrayBufferViewSubTag* tag)
+bool SerializedScriptValueReader::readArrayBufferViewSubTag(ArrayBufferViewSubTag* tag)
 {
     if (m_position >= m_length)
         return false;
@@ -1457,7 +1249,7 @@ bool Reader::readArrayBufferViewSubTag(ArrayBufferViewSubTag* tag)
     return true;
 }
 
-bool Reader::readString(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readString(v8::Handle<v8::Value>* value)
 {
     uint32_t length;
     if (!doReadUint32(&length))
@@ -1469,7 +1261,7 @@ bool Reader::readString(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readUCharString(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readUCharString(v8::Handle<v8::Value>* value)
 {
     uint32_t length;
     if (!doReadUint32(&length) || (length & 1))
@@ -1482,7 +1274,7 @@ bool Reader::readUCharString(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readStringObject(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readStringObject(v8::Handle<v8::Value>* value)
 {
     v8::Handle<v8::Value> stringValue;
     if (!readString(&stringValue) || !stringValue->IsString())
@@ -1491,7 +1283,7 @@ bool Reader::readStringObject(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readWebCoreString(String* string)
+bool SerializedScriptValueReader::readWebCoreString(String* string)
 {
     uint32_t length;
     if (!doReadUint32(&length))
@@ -1503,7 +1295,7 @@ bool Reader::readWebCoreString(String* string)
     return true;
 }
 
-bool Reader::readInt32(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readInt32(v8::Handle<v8::Value>* value)
 {
     uint32_t rawValue;
     if (!doReadUint32(&rawValue))
@@ -1512,7 +1304,7 @@ bool Reader::readInt32(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readUint32(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readUint32(v8::Handle<v8::Value>* value)
 {
     uint32_t rawValue;
     if (!doReadUint32(&rawValue))
@@ -1521,7 +1313,7 @@ bool Reader::readUint32(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readDate(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readDate(v8::Handle<v8::Value>* value)
 {
     double numberValue;
     if (!doReadNumber(&numberValue))
@@ -1530,7 +1322,7 @@ bool Reader::readDate(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readNumber(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readNumber(v8::Handle<v8::Value>* value)
 {
     double number;
     if (!doReadNumber(&number))
@@ -1539,7 +1331,7 @@ bool Reader::readNumber(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readNumberObject(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readNumberObject(v8::Handle<v8::Value>* value)
 {
     double number;
     if (!doReadNumber(&number))
@@ -1548,7 +1340,7 @@ bool Reader::readNumberObject(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readImageData(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readImageData(v8::Handle<v8::Value>* value)
 {
     uint32_t width;
     uint32_t height;
@@ -1571,7 +1363,7 @@ bool Reader::readImageData(v8::Handle<v8::Value>* value)
     return true;
 }
 
-PassRefPtr<ArrayBuffer> Reader::doReadArrayBuffer()
+PassRefPtr<ArrayBuffer> SerializedScriptValueReader::doReadArrayBuffer()
 {
     uint32_t byteLength;
     if (!doReadUint32(&byteLength))
@@ -1583,7 +1375,7 @@ PassRefPtr<ArrayBuffer> Reader::doReadArrayBuffer()
     return ArrayBuffer::create(bufferStart, byteLength);
 }
 
-bool Reader::readArrayBuffer(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readArrayBuffer(v8::Handle<v8::Value>* value)
 {
     RefPtr<ArrayBuffer> arrayBuffer = doReadArrayBuffer();
     if (!arrayBuffer)
@@ -1592,7 +1384,7 @@ bool Reader::readArrayBuffer(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readArrayBufferView(v8::Handle<v8::Value>* value, CompositeCreator& creator)
+bool SerializedScriptValueReader::readArrayBufferView(v8::Handle<v8::Value>* value, ScriptValueCompositeCreator& creator)
 {
     ArrayBufferViewSubTag subTag;
     uint32_t byteOffset;
@@ -1678,7 +1470,7 @@ bool Reader::readArrayBufferView(v8::Handle<v8::Value>* value, CompositeCreator&
     return !value->IsEmpty();
 }
 
-bool Reader::readRegExp(v8::Handle<v8::Value>* value)
+bool SerializedScriptValueReader::readRegExp(v8::Handle<v8::Value>* value)
 {
     v8::Handle<v8::Value> pattern;
     if (!readString(&pattern))
@@ -1690,7 +1482,7 @@ bool Reader::readRegExp(v8::Handle<v8::Value>* value)
     return true;
 }
 
-bool Reader::readBlob(v8::Handle<v8::Value>* value, bool isIndexed)
+bool SerializedScriptValueReader::readBlob(v8::Handle<v8::Value>* value, bool isIndexed)
 {
     if (m_version < 3)
         return false;
@@ -1722,23 +1514,7 @@ bool Reader::readBlob(v8::Handle<v8::Value>* value, bool isIndexed)
     return true;
 }
 
-bool Reader::readDOMFileSystem(v8::Handle<v8::Value>* value)
-{
-    uint32_t type;
-    String name;
-    String url;
-    if (!doReadUint32(&type))
-        return false;
-    if (!readWebCoreString(&name))
-        return false;
-    if (!readWebCoreString(&url))
-        return false;
-    DOMFileSystem* fs = DOMFileSystem::create(m_scriptState->executionContext(), name, static_cast<FileSystemType>(type), KURL(ParsedURLString, url));
-    *value = toV8(fs, m_scriptState->context()->Global(), isolate());
-    return true;
-}
-
-bool Reader::readFile(v8::Handle<v8::Value>* value, bool isIndexed)
+bool SerializedScriptValueReader::readFile(v8::Handle<v8::Value>* value, bool isIndexed)
 {
     File* file = nullptr;
     if (isIndexed) {
@@ -1754,7 +1530,7 @@ bool Reader::readFile(v8::Handle<v8::Value>* value, bool isIndexed)
     return true;
 }
 
-bool Reader::readFileList(v8::Handle<v8::Value>* value, bool isIndexed)
+bool SerializedScriptValueReader::readFileList(v8::Handle<v8::Value>* value, bool isIndexed)
 {
     if (m_version < 3)
         return false;
@@ -1779,62 +1555,7 @@ bool Reader::readFileList(v8::Handle<v8::Value>* value, bool isIndexed)
     return true;
 }
 
-bool Reader::readCryptoKey(v8::Handle<v8::Value>* value)
-{
-    uint32_t rawKeyType;
-    if (!doReadUint32(&rawKeyType))
-        return false;
-
-    WebCryptoKeyAlgorithm algorithm;
-    WebCryptoKeyType type = WebCryptoKeyTypeSecret;
-
-    switch (static_cast<CryptoKeySubTag>(rawKeyType)) {
-    case AesKeyTag:
-        if (!doReadAesKey(algorithm, type))
-            return false;
-        break;
-    case HmacKeyTag:
-        if (!doReadHmacKey(algorithm, type))
-            return false;
-        break;
-    case RsaHashedKeyTag:
-        if (!doReadRsaHashedKey(algorithm, type))
-            return false;
-        break;
-    case EcKeyTag:
-        if (!doReadEcKey(algorithm, type))
-            return false;
-        break;
-    default:
-        return false;
-    }
-
-    WebCryptoKeyUsageMask usages;
-    bool extractable;
-    if (!doReadKeyUsages(usages, extractable))
-        return false;
-
-    uint32_t keyDataLength;
-    if (!doReadUint32(&keyDataLength))
-        return false;
-
-    if (m_position + keyDataLength > m_length)
-        return false;
-
-    const uint8_t* keyData = m_buffer + m_position;
-    m_position += keyDataLength;
-
-    WebCryptoKey key = WebCryptoKey::createNull();
-    if (!Platform::current()->crypto()->deserializeKeyForClone(
-        algorithm, type, extractable, usages, keyData, keyDataLength, key)) {
-        return false;
-    }
-
-    *value = toV8(CryptoKey::create(key), m_scriptState->context()->Global(), isolate());
-    return true;
-}
-
-File* Reader::readFileHelper()
+File* SerializedScriptValueReader::readFileHelper()
 {
     if (m_version < 3)
         return nullptr;
@@ -1872,7 +1593,7 @@ File* Reader::readFileHelper()
     return File::createFromSerialization(path, name, relativePath, userVisibility, hasSnapshot > 0, size, lastModified, getOrCreateBlobDataHandle(uuid, type));
 }
 
-File* Reader::readFileIndexHelper()
+File* SerializedScriptValueReader::readFileIndexHelper()
 {
     if (m_version < 3)
         return nullptr;
@@ -1884,17 +1605,17 @@ File* Reader::readFileIndexHelper()
     return File::createFromIndexedSerialization(info.filePath(), info.fileName(), info.size(), info.lastModified(), getOrCreateBlobDataHandle(info.uuid(), info.type(), info.size()));
 }
 
-bool Reader::doReadUint32(uint32_t* value)
+bool SerializedScriptValueReader::doReadUint32(uint32_t* value)
 {
     return doReadUintHelper(value);
 }
 
-bool Reader::doReadUint64(uint64_t* value)
+bool SerializedScriptValueReader::doReadUint64(uint64_t* value)
 {
     return doReadUintHelper(value);
 }
 
-bool Reader::doReadNumber(double* number)
+bool SerializedScriptValueReader::doReadNumber(double* number)
 {
     if (m_position + sizeof(double) > m_length)
         return false;
@@ -1904,7 +1625,7 @@ bool Reader::doReadNumber(double* number)
     return true;
 }
 
-PassRefPtr<BlobDataHandle> Reader::getOrCreateBlobDataHandle(const String& uuid, const String& type, long long size)
+PassRefPtr<BlobDataHandle> SerializedScriptValueReader::getOrCreateBlobDataHandle(const String& uuid, const String& type, long long size)
 {
     // The containing ssv may have a BDH for this uuid if this ssv is just being
     // passed from main to worker thread (for example). We use those values when creating
@@ -1924,209 +1645,7 @@ PassRefPtr<BlobDataHandle> Reader::getOrCreateBlobDataHandle(const String& uuid,
     return BlobDataHandle::create(uuid, type, size);
 }
 
-bool Reader::doReadHmacKey(WebCryptoKeyAlgorithm& algorithm, WebCryptoKeyType& type)
-{
-    uint32_t lengthBytes;
-    if (!doReadUint32(&lengthBytes))
-        return false;
-    WebCryptoAlgorithmId hash;
-    if (!doReadAlgorithmId(hash))
-        return false;
-    algorithm = WebCryptoKeyAlgorithm::createHmac(hash, lengthBytes * 8);
-    type = WebCryptoKeyTypeSecret;
-    return !algorithm.isNull();
-}
-
-bool Reader::doReadAesKey(WebCryptoKeyAlgorithm& algorithm, WebCryptoKeyType& type)
-{
-    WebCryptoAlgorithmId id;
-    if (!doReadAlgorithmId(id))
-        return false;
-    uint32_t lengthBytes;
-    if (!doReadUint32(&lengthBytes))
-        return false;
-    algorithm = WebCryptoKeyAlgorithm::createAes(id, lengthBytes * 8);
-    type = WebCryptoKeyTypeSecret;
-    return !algorithm.isNull();
-}
-
-bool Reader::doReadRsaHashedKey(WebCryptoKeyAlgorithm& algorithm, WebCryptoKeyType& type)
-{
-    WebCryptoAlgorithmId id;
-    if (!doReadAlgorithmId(id))
-        return false;
-
-    if (!doReadAsymmetricKeyType(type))
-        return false;
-
-    uint32_t modulusLengthBits;
-    if (!doReadUint32(&modulusLengthBits))
-        return false;
-
-    uint32_t publicExponentSize;
-    if (!doReadUint32(&publicExponentSize))
-        return false;
-
-    if (m_position + publicExponentSize > m_length)
-        return false;
-
-    const uint8_t* publicExponent = m_buffer + m_position;
-    m_position += publicExponentSize;
-
-    WebCryptoAlgorithmId hash;
-    if (!doReadAlgorithmId(hash))
-        return false;
-    algorithm = WebCryptoKeyAlgorithm::createRsaHashed(id, modulusLengthBits, publicExponent, publicExponentSize, hash);
-
-    return !algorithm.isNull();
-}
-
-bool Reader::doReadEcKey(WebCryptoKeyAlgorithm& algorithm, WebCryptoKeyType& type)
-{
-    WebCryptoAlgorithmId id;
-    if (!doReadAlgorithmId(id))
-        return false;
-
-    if (!doReadAsymmetricKeyType(type))
-        return false;
-
-    WebCryptoNamedCurve namedCurve;
-    if (!doReadNamedCurve(namedCurve))
-        return false;
-
-    algorithm = WebCryptoKeyAlgorithm::createEc(id, namedCurve);
-    return !algorithm.isNull();
-}
-
-bool Reader::doReadAlgorithmId(WebCryptoAlgorithmId& id)
-{
-    uint32_t rawId;
-    if (!doReadUint32(&rawId))
-        return false;
-
-    switch (static_cast<CryptoKeyAlgorithmTag>(rawId)) {
-    case AesCbcTag:
-        id = WebCryptoAlgorithmIdAesCbc;
-        return true;
-    case HmacTag:
-        id = WebCryptoAlgorithmIdHmac;
-        return true;
-    case RsaSsaPkcs1v1_5Tag:
-        id = WebCryptoAlgorithmIdRsaSsaPkcs1v1_5;
-        return true;
-    case Sha1Tag:
-        id = WebCryptoAlgorithmIdSha1;
-        return true;
-    case Sha256Tag:
-        id = WebCryptoAlgorithmIdSha256;
-        return true;
-    case Sha384Tag:
-        id = WebCryptoAlgorithmIdSha384;
-        return true;
-    case Sha512Tag:
-        id = WebCryptoAlgorithmIdSha512;
-        return true;
-    case AesGcmTag:
-        id = WebCryptoAlgorithmIdAesGcm;
-        return true;
-    case RsaOaepTag:
-        id = WebCryptoAlgorithmIdRsaOaep;
-        return true;
-    case AesCtrTag:
-        id = WebCryptoAlgorithmIdAesCtr;
-        return true;
-    case AesKwTag:
-        id = WebCryptoAlgorithmIdAesKw;
-        return true;
-    case RsaPssTag:
-        id = WebCryptoAlgorithmIdRsaPss;
-        return true;
-    case EcdsaTag:
-        id = WebCryptoAlgorithmIdEcdsa;
-        return true;
-    }
-
-    return false;
-}
-
-bool Reader::doReadAsymmetricKeyType(WebCryptoKeyType& type)
-{
-    uint32_t rawType;
-    if (!doReadUint32(&rawType))
-        return false;
-
-    switch (static_cast<AssymetricCryptoKeyType>(rawType)) {
-    case PublicKeyType:
-        type = WebCryptoKeyTypePublic;
-        return true;
-    case PrivateKeyType:
-        type = WebCryptoKeyTypePrivate;
-        return true;
-    }
-
-    return false;
-}
-
-bool Reader::doReadNamedCurve(WebCryptoNamedCurve& namedCurve)
-{
-    uint32_t rawName;
-    if (!doReadUint32(&rawName))
-        return false;
-
-    switch (static_cast<NamedCurveTag>(rawName)) {
-    case P256Tag:
-        namedCurve = WebCryptoNamedCurveP256;
-        return true;
-    case P384Tag:
-        namedCurve = WebCryptoNamedCurveP384;
-        return true;
-    case P521Tag:
-        namedCurve = WebCryptoNamedCurveP521;
-        return true;
-    }
-
-    return false;
-}
-
-bool Reader::doReadKeyUsages(WebCryptoKeyUsageMask& usages, bool& extractable)
-{
-    // Reminder to update this when adding new key usages.
-    COMPILE_ASSERT(EndOfWebCryptoKeyUsage == (1 << 7) + 1, UpdateMe);
-    const uint32_t allPossibleUsages = ExtractableUsage | EncryptUsage | DecryptUsage | SignUsage | VerifyUsage | DeriveKeyUsage | WrapKeyUsage | UnwrapKeyUsage | DeriveBitsUsage;
-
-    uint32_t rawUsages;
-    if (!doReadUint32(&rawUsages))
-        return false;
-
-    // Make sure it doesn't contain an unrecognized usage value.
-    if (rawUsages & ~allPossibleUsages)
-        return false;
-
-    usages = 0;
-
-    extractable = rawUsages & ExtractableUsage;
-
-    if (rawUsages & EncryptUsage)
-        usages |= WebCryptoKeyUsageEncrypt;
-    if (rawUsages & DecryptUsage)
-        usages |= WebCryptoKeyUsageDecrypt;
-    if (rawUsages & SignUsage)
-        usages |= WebCryptoKeyUsageSign;
-    if (rawUsages & VerifyUsage)
-        usages |= WebCryptoKeyUsageVerify;
-    if (rawUsages & DeriveKeyUsage)
-        usages |= WebCryptoKeyUsageDeriveKey;
-    if (rawUsages & WrapKeyUsage)
-        usages |= WebCryptoKeyUsageWrapKey;
-    if (rawUsages & UnwrapKeyUsage)
-        usages |= WebCryptoKeyUsageUnwrapKey;
-    if (rawUsages & DeriveBitsUsage)
-        usages |= WebCryptoKeyUsageDeriveBits;
-
-    return true;
-}
-
-v8::Handle<v8::Value> Deserializer::deserialize()
+v8::Handle<v8::Value> ScriptValueDeserializer::deserialize()
 {
     v8::Isolate* isolate = m_reader.scriptState()->isolate();
     if (!m_reader.readVersion(m_version) || m_version > SerializedScriptValue::wireFormatVersion)
@@ -2143,21 +1662,21 @@ v8::Handle<v8::Value> Deserializer::deserialize()
     return result;
 }
 
-bool Deserializer::newSparseArray(uint32_t)
+bool ScriptValueDeserializer::newSparseArray(uint32_t)
 {
     v8::Local<v8::Array> array = v8::Array::New(m_reader.scriptState()->isolate(), 0);
     openComposite(array);
     return true;
 }
 
-bool Deserializer::newDenseArray(uint32_t length)
+bool ScriptValueDeserializer::newDenseArray(uint32_t length)
 {
     v8::Local<v8::Array> array = v8::Array::New(m_reader.scriptState()->isolate(), length);
     openComposite(array);
     return true;
 }
 
-bool Deserializer::consumeTopOfStack(v8::Handle<v8::Value>* object)
+bool ScriptValueDeserializer::consumeTopOfStack(v8::Handle<v8::Value>* object)
 {
     if (stackDepth() < 1)
         return false;
@@ -2166,7 +1685,7 @@ bool Deserializer::consumeTopOfStack(v8::Handle<v8::Value>* object)
     return true;
 }
 
-bool Deserializer::newObject()
+bool ScriptValueDeserializer::newObject()
 {
     v8::Local<v8::Object> object = v8::Object::New(m_reader.scriptState()->isolate());
     if (object.IsEmpty())
@@ -2175,7 +1694,7 @@ bool Deserializer::newObject()
     return true;
 }
 
-bool Deserializer::completeObject(uint32_t numProperties, v8::Handle<v8::Value>* value)
+bool ScriptValueDeserializer::completeObject(uint32_t numProperties, v8::Handle<v8::Value>* value)
 {
     v8::Local<v8::Object> object;
     if (m_version > 0) {
@@ -2191,7 +1710,7 @@ bool Deserializer::completeObject(uint32_t numProperties, v8::Handle<v8::Value>*
     return initializeObject(object, numProperties, value);
 }
 
-bool Deserializer::completeSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
+bool ScriptValueDeserializer::completeSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
 {
     v8::Local<v8::Array> array;
     if (m_version > 0) {
@@ -2207,7 +1726,7 @@ bool Deserializer::completeSparseArray(uint32_t numProperties, uint32_t length,
     return initializeObject(array, numProperties, value);
 }
 
-bool Deserializer::completeDenseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
+bool ScriptValueDeserializer::completeDenseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
 {
     v8::Local<v8::Array> array;
     if (m_version > 0) {
@@ -2231,12 +1750,12 @@ bool Deserializer::completeDenseArray(uint32_t numProperties, uint32_t length, v
     return true;
 }
 
-void Deserializer::pushObjectReference(const v8::Handle<v8::Value>& object)
+void ScriptValueDeserializer::pushObjectReference(const v8::Handle<v8::Value>& object)
 {
     m_objectPool.append(object);
 }
 
-bool Deserializer::tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::Value>* object)
+bool ScriptValueDeserializer::tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::Value>* object)
 {
     if (!m_transferredMessagePorts)
         return false;
@@ -2247,7 +1766,7 @@ bool Deserializer::tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::V
     return true;
 }
 
-bool Deserializer::tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::Value>* object)
+bool ScriptValueDeserializer::tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::Value>* object)
 {
     if (!m_arrayBufferContents)
         return false;
@@ -2265,7 +1784,7 @@ bool Deserializer::tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::V
     return true;
 }
 
-bool Deserializer::tryGetObjectFromObjectReference(uint32_t reference, v8::Handle<v8::Value>* object)
+bool ScriptValueDeserializer::tryGetObjectFromObjectReference(uint32_t reference, v8::Handle<v8::Value>* object)
 {
     if (reference >= m_objectPool.size())
         return false;
@@ -2273,12 +1792,12 @@ bool Deserializer::tryGetObjectFromObjectReference(uint32_t reference, v8::Handl
     return object;
 }
 
-uint32_t Deserializer::objectReferenceCount()
+uint32_t ScriptValueDeserializer::objectReferenceCount()
 {
     return m_objectPool.size();
 }
 
-bool Deserializer::initializeObject(v8::Handle<v8::Object> object, uint32_t numProperties, v8::Handle<v8::Value>* value)
+bool ScriptValueDeserializer::initializeObject(v8::Handle<v8::Object> object, uint32_t numProperties, v8::Handle<v8::Value>* value)
 {
     unsigned length = 2 * numProperties;
     if (length > stackDepth())
@@ -2293,12 +1812,12 @@ bool Deserializer::initializeObject(v8::Handle<v8::Object> object, uint32_t numP
     return true;
 }
 
-bool Deserializer::read(v8::Local<v8::Value>* value)
+bool ScriptValueDeserializer::read(v8::Local<v8::Value>* value)
 {
     return m_reader.read(value, *this);
 }
 
-bool Deserializer::doDeserialize()
+bool ScriptValueDeserializer::doDeserialize()
 {
     v8::Local<v8::Value> value;
     if (!read(&value))
@@ -2308,20 +1827,20 @@ bool Deserializer::doDeserialize()
     return true;
 }
 
-v8::Local<v8::Value> Deserializer::element(unsigned index)
+v8::Local<v8::Value> ScriptValueDeserializer::element(unsigned index)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < m_stack.size());
     return m_stack[index];
 }
 
-void Deserializer::openComposite(const v8::Local<v8::Value>& object)
+void ScriptValueDeserializer::openComposite(const v8::Local<v8::Value>& object)
 {
     uint32_t newObjectReference = m_objectPool.size();
     m_openCompositeReferenceStack.append(newObjectReference);
     m_objectPool.append(object);
 }
 
-bool Deserializer::closeComposite(v8::Handle<v8::Value>* object)
+bool ScriptValueDeserializer::closeComposite(v8::Handle<v8::Value>* object)
 {
     if (!m_openCompositeReferenceStack.size())
         return false;
@@ -2333,6 +1852,4 @@ bool Deserializer::closeComposite(v8::Handle<v8::Value>* object)
     return true;
 }
 
-} // SerializedScriptValueInternal
-
 } // namespace blink