bindings: fixed incorrect dependency of SerializedScriptValue.

Source/bindings/core/v8/ScriptValueSerializer.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8File.h"
 #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"
 #include "core/fileapi/FileList.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebBlobInfo.h"
 #include "wtf/ArrayBuffer.h"
 #include "wtf/ArrayBufferContents.h"
 #include "wtf/ArrayBufferView.h"
 #include "wtf/text/StringHash.h"
@@ skipping 163 matching lines @@
 }
 
 void Writer::writeBlob(const String& uuid, const String& type, unsigned long long size)
 {
     append(BlobTag);
     doWriteWebCoreString(uuid);
     doWriteWebCoreString(type);
     doWriteUint64(size);
 }
 
-void Writer::writeDOMFileSystem(int type, const String& name, const String& url)
-{
-    append(DOMFileSystemTag);
-    doWriteUint32(type);
-    doWriteWebCoreString(name);
-    doWriteWebCoreString(url);
-}
-

[tasak, 2014/11/14 08:07:39]

Moved to ScriptValueSerializerForModules.cpp

 void Writer::writeBlobIndex(int blobIndex)
 {
     ASSERT(blobIndex >= 0);
     append(BlobIndexTag);
     doWriteUint32(blobIndex);
 }
 
 void Writer::writeFile(const File& file)
 {
     append(FileTag);
@@ skipping 17 matching lines @@
 
 void Writer::writeFileListIndex(const Vector<int>& blobIndices)
 {
     append(FileListIndexTag);
     uint32_t length = blobIndices.size();
     doWriteUint32(length);
     for (unsigned i = 0; i < length; ++i)
         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)
 {
     append(ArrayBufferTag);
     doWriteArrayBuffer(arrayBuffer);
 }
 
 void Writer::writeArrayBufferView(const ArrayBufferView& arrayBufferView)
 {
     append(ArrayBufferViewTag);
 #if ENABLE(ASSERT)
@@ skipping 152 matching lines @@
     doWriteUint32(static_cast<uint32_t>(length));
     append(reinterpret_cast<const uint8_t*>(data), length);
 }
 
 void Writer::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 bytes = 1;
     while (true) {
         value >>= SerializedScriptValue::varIntShift;
         if (!value)
             break;
         ++bytes;
     }
 
@@ skipping 264 matching lines @@
         } else if (value->IsNumberObject()) {
             writeNumberObject(value);
         } else if (value->IsBooleanObject()) {
             writeBooleanObject(value);
         } else if (value->IsArray()) {
             return startArrayState(value.As<v8::Array>(), next);
         } else if (V8File::hasInstance(value, isolate())) {
             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()) {
             writeRegExp(value);
         } else if (V8ArrayBuffer::hasInstance(value, isolate())) {
             return writeArrayBuffer(value, next);
         } else if (value->IsObject()) {
             if (isHostObject(jsObject) || jsObject->IsCallable() || value->IsNativeError())
                 return handleError(DataCloneError, "An object could not be cloned.", next);
             return startObjectState(jsObject, next);
@@ skipping 97 matching lines @@
         return handleError(DataCloneError, "A Blob object has been closed, and could therefore not be cloned.", next);
     int blobIndex = -1;
     m_blobDataHandles.set(blob->uuid(), blob->blobDataHandle());
     if (appendBlobInfo(blob->uuid(), blob->type(), blob->size(), &blobIndex))
         m_writer.writeBlobIndex(blobIndex);
     else
         m_writer.writeBlob(blob->uuid(), blob->type(), blob->size());
     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)
 {
     File* file = V8File::toImpl(value.As<v8::Object>());
     if (!file)
         return 0;
     if (file->hasBeenClosed())
         return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
     int blobIndex = -1;
     m_blobDataHandles.set(file->uuid(), file->blobDataHandle());
     if (appendFileInfo(file, &blobIndex)) {
@@ skipping 24 matching lines @@
             blobIndices.append(blobIndex);
         }
     }
     if (!blobIndices.isEmpty())
         m_writer.writeFileListIndex(blobIndices);
     else
         m_writer.writeFileList(*fileList);
     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)
 {
     ImageData* imageData = V8ImageData::toImpl(value.As<v8::Object>());
     if (!imageData)
         return;
     Uint8ClampedArray* pixelArray = imageData->data();
     m_writer.writeImageData(imageData->width(), imageData->height(), pixelArray->data(), pixelArray->length());
 }
 
 void Serializer::writeRegExp(v8::Handle<v8::Value> value)
@@ skipping 115 matching lines @@
     *index = m_blobInfo->size();
     m_blobInfo->append(WebBlobInfo(file->uuid(), file->path(), file->name(), file->type(), lastModified, size));
     return true;
 }
 
 bool Reader::read(v8::Handle<v8::Value>* value, CompositeCreator& creator)
 {
     SerializationTag tag;
     if (!readTag(&tag))
         return false;
+    return readWithTag(tag, value, creator);
+}
+
+bool Reader::readWithTag(SerializationTag tag, v8::Handle<v8::Value>* value, CompositeCreator& creator)
+{
     switch (tag) {
     case ReferenceCountTag: {
         if (!m_version)
             return false;
         uint32_t referenceTableSize;
         if (!doReadUint32(&referenceTableSize))
             return false;
         // If this test fails, then the serializer and deserializer disagree about the assignment
         // of object reference IDs. On the deserialization side, this means there are too many or too few
         // calls to pushObjectReference.
@@ skipping 65 matching lines @@
         if (!readBlob(value, tag == BlobIndexTag))
             return false;
         creator.pushObjectReference(*value);
         break;
     case FileTag:
     case FileIndexTag:
         if (!readFile(value, tag == FileIndexTag))
             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;
         creator.pushObjectReference(*value);
         break;
 
     case RegExpTag:
         if (!readRegExp(value))
             return false;
         creator.pushObjectReference(*value);
@@ skipping 94 matching lines @@
     case ObjectReferenceTag: {
         if (!m_version)
             return false;
         uint32_t reference;
         if (!doReadUint32(&reference))
             return false;
         if (!creator.tryGetObjectFromObjectReference(reference, value))
             return false;
         break;
     }
+    case DOMFileSystemTag:
+    case CryptoKeyTag:
+        ASSERT_NOT_REACHED();
     default:
         return false;
     }
     return !value->IsEmpty();
 }
 
 bool Reader::readVersion(uint32_t& version)
 {
     SerializationTag tag;
     if (!readTag(&tag)) {
@@ skipping 297 matching lines @@
         if (!readWebCoreString(&type))
             return false;
         if (!doReadUint64(&size))
             return false;
         blob = Blob::create(getOrCreateBlobDataHandle(uuid, type, size));
     }
     *value = toV8(blob, m_scriptState->context()->Global(), isolate());
     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)
 {
     File* file = nullptr;
     if (isIndexed) {
         if (m_version < 6)
             return false;
         file = readFileIndexHelper();
     } else {
         file = readFileHelper();
     }
@@ skipping 21 matching lines @@
             file = readFileHelper();
         }
         if (!file)
             return false;
         fileList->append(file);
     }
     *value = toV8(fileList, m_scriptState->context()->Global(), isolate());
     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()
 {
     if (m_version < 3)
         return nullptr;
     ASSERT(!m_blobInfo);
     String path;
     String name;
     String relativePath;
     String uuid;
     String type;
@@ skipping 70 matching lines @@
     // the blob in the src process happens to still exist at the time the dest process is deserializing.
     // For example in sharedWorker.postMessage(...).
     BlobDataHandleMap::const_iterator it = m_blobDataHandles.find(uuid);
     if (it != m_blobDataHandles.end()) {
         // make assertions about type and size?
         return it->value;
     }
     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::Isolate* isolate = m_reader.scriptState()->isolate();
     if (!m_reader.readVersion(m_version) || m_version > SerializedScriptValue::wireFormatVersion)
         return v8::Null(isolate);
     m_reader.setVersion(m_version);
     v8::EscapableHandleScope scope(isolate);
     while (!m_reader.isEof()) {
         if (!doDeserialize())
             return v8::Null(isolate);
@@ skipping 190 matching lines @@
     m_openCompositeReferenceStack.shrink(m_openCompositeReferenceStack.size() - 1);
     if (objectReference >= m_objectPool.size())
         return false;
     *object = m_objectPool[objectReference];
     return true;
 }
 
 } // SerializedScriptValueInternal
 
 } // namespace blink