bindings: fixed incorrect dependency of SerializedScriptValue.

Source/bindings/core/v8/ScriptValueSerializer.h

 // 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.
 
 #ifndef ScriptValueSerializer_h
 #define ScriptValueSerializer_h
 
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
-#include "public/platform/WebCrypto.h"
-#include "public/platform/WebCryptoKey.h"
-#include "public/platform/WebCryptoKeyAlgorithm.h"
 #include "wtf/ArrayBufferContents.h"
 #include "wtf/HashMap.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include <v8.h>
 
 namespace WTF {
 
 class ArrayBuffer;
@@ skipping 100 matching lines @@
     void writeStringObject(const char* data, int length);
     void writeWebCoreString(const String&);
     void writeVersion();
     void writeInt32(int32_t value);
     void writeUint32(uint32_t value);
     void writeDate(double numberValue);
     void writeNumber(double number);
     void writeNumberObject(double number);
     void writeBlob(const String& uuid, const String& type, unsigned long long size);
     void writeBlobIndex(int blobIndex);
-    void writeDOMFileSystem(int type, const String& name, const String& url);
     void writeFile(const File&);
     void writeFileIndex(int blobIndex);
     void writeFileList(const FileList&);
     void writeFileListIndex(const Vector<int>& blobIndices);
-    bool writeCryptoKey(const WebCryptoKey&);
     void writeArrayBuffer(const ArrayBuffer&);
     void writeArrayBufferView(const ArrayBufferView&);
     void writeImageData(uint32_t width, uint32_t height, const uint8_t* pixelData, uint32_t pixelDataLength);
     void writeRegExp(v8::Local<v8::String> pattern, v8::RegExp::Flags);
     void writeTransferredMessagePort(uint32_t index);
     void writeTransferredArrayBuffer(uint32_t index);
     void writeObjectReference(uint32_t reference);
     void writeObject(uint32_t numProperties);
     void writeSparseArray(uint32_t numProperties, uint32_t length);
     void writeDenseArray(uint32_t numProperties, uint32_t length);
     String takeWireString();
     void writeReferenceCount(uint32_t numberOfReferences);
     void writeGenerateFreshObject();
     void writeGenerateFreshSparseArray(uint32_t length);
     void writeGenerateFreshDenseArray(uint32_t length);
 
 protected:
     void doWriteFile(const File&);
     void doWriteArrayBuffer(const ArrayBuffer&);
     void doWriteString(const char* data, int length);
     void doWriteWebCoreString(const String&);
-    void doWriteHmacKey(const WebCryptoKey&);
-    void doWriteAesKey(const WebCryptoKey&);
-    void doWriteRsaHashedKey(const WebCryptoKey&);
-    void doWriteEcKey(const WebCryptoKey&);
-    void doWriteAlgorithmId(WebCryptoAlgorithmId);
-    void doWriteAsymmetricKeyType(WebCryptoKeyType);
-    void doWriteNamedCurve(WebCryptoNamedCurve);
-    void doWriteKeyUsages(const WebCryptoKeyUsageMask usages, bool extractable);
     int bytesNeededToWireEncode(uint32_t value);
 
     template<class T>
     void doWriteUintHelper(T value)
     {
         while (true) {
             uint8_t b = (value & SerializedScriptValue::varIntMask);
             value >>= SerializedScriptValue::varIntShift;
             if (!value) {
                 append(b);
@@ skipping 32 matching lines @@
         JSException
     };
 
     Serializer(Writer&, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, WebBlobInfoArray*, BlobDataHandleMap& blobDataHandles, v8::TryCatch&, ScriptState*);
     v8::Isolate* isolate() { return m_scriptState->isolate(); }
 
     Status serialize(v8::Handle<v8::Value>);
     String errorMessage() { return m_errorMessage; }
 
     // Functions used by serialization states.
-    Serializer::StateBase* doSerialize(v8::Handle<v8::Value>, Serializer::StateBase* next);
+    virtual Serializer::StateBase* doSerialize(v8::Handle<v8::Value>, Serializer::StateBase* next);
 
     StateBase* doSerializeArrayBuffer(v8::Handle<v8::Value> arrayBuffer, StateBase* next);
     StateBase* checkException(StateBase*);
     StateBase* writeObject(uint32_t numProperties, StateBase*);
     StateBase* writeSparseArray(uint32_t numProperties, uint32_t length, StateBase*);
     StateBase* writeDenseArray(uint32_t numProperties, uint32_t length, StateBase*);
 
 protected:
     class StateBase {
         WTF_MAKE_NONCOPYABLE(StateBase);
@@ skipping 136 matching lines @@
         delete state;
         return next;
     }
 
     bool checkComposite(StateBase* top);
     void writeString(v8::Handle<v8::Value>);
     void writeStringObject(v8::Handle<v8::Value>);
     void writeNumberObject(v8::Handle<v8::Value>);
     void writeBooleanObject(v8::Handle<v8::Value>);
     StateBase* writeBlob(v8::Handle<v8::Value>, StateBase* next);
-    StateBase* writeDOMFileSystem(v8::Handle<v8::Value>, StateBase* next);
     StateBase* writeFile(v8::Handle<v8::Value>, StateBase* next);
     StateBase* writeFileList(v8::Handle<v8::Value>, StateBase* next);
-    bool writeCryptoKey(v8::Handle<v8::Value>);
     void writeImageData(v8::Handle<v8::Value>);
     void writeRegExp(v8::Handle<v8::Value>);
     StateBase* writeAndGreyArrayBufferView(v8::Handle<v8::Object>, StateBase* next);
     StateBase* writeArrayBuffer(v8::Handle<v8::Value>, StateBase* next);
     StateBase* writeTransferredArrayBuffer(v8::Handle<v8::Value>, uint32_t index, StateBase* next);
     static bool shouldSerializeDensely(uint32_t length, uint32_t propertyCount);
 
     StateBase* startArrayState(v8::Handle<v8::Array>, StateBase* next);
     StateBase* startObjectState(v8::Handle<v8::Object>, StateBase* next);
 
@@ skipping 76 matching lines @@
     unsigned position() const { return m_position; }
 
     const uint8_t* allocate(uint32_t size)
     {
         const uint8_t* allocated = m_buffer + m_position;
         m_position += size;
         return allocated;
     }
 
 public:
-    bool read(v8::Handle<v8::Value>*, CompositeCreator&);
+    virtual bool read(v8::Handle<v8::Value>*, CompositeCreator&);
     bool readVersion(uint32_t& version);
     void setVersion(uint32_t);
 
-private:
+protected:
+    bool readWithTag(SerializationTag, v8::Handle<v8::Value>*, CompositeCreator&);
+
     bool readTag(SerializationTag*);
     bool readWebCoreString(String*);
     bool readUint32(v8::Handle<v8::Value>*);
+
+    bool doReadUint32(uint32_t* value);
+
+private:
     void undoReadTag();
     bool readArrayBufferViewSubTag(ArrayBufferViewSubTag*);
     bool readString(v8::Handle<v8::Value>*);
     bool readUCharString(v8::Handle<v8::Value>*);
     bool readStringObject(v8::Handle<v8::Value>*);
     bool readInt32(v8::Handle<v8::Value>*);
     bool readDate(v8::Handle<v8::Value>*);
     bool readNumber(v8::Handle<v8::Value>*);
     bool readNumberObject(v8::Handle<v8::Value>*);
     bool readImageData(v8::Handle<v8::Value>*);
     PassRefPtr<ArrayBuffer> doReadArrayBuffer();
     bool readArrayBuffer(v8::Handle<v8::Value>*);
     bool readArrayBufferView(v8::Handle<v8::Value>*, CompositeCreator&);
     bool readRegExp(v8::Handle<v8::Value>*);
     bool readBlob(v8::Handle<v8::Value>*, bool isIndexed);
-    bool readDOMFileSystem(v8::Handle<v8::Value>*);
     bool readFile(v8::Handle<v8::Value>*, bool isIndexed);
     bool readFileList(v8::Handle<v8::Value>*, bool isIndexed);
-    bool readCryptoKey(v8::Handle<v8::Value>*);
     File* readFileHelper();
     File* readFileIndexHelper();
 
     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 & SerializedScriptValue::varIntMask) << shift);
             shift += SerializedScriptValue::varIntShift;
         } while (currentByte & (1 << SerializedScriptValue::varIntShift));
         return true;
     }
 
-    bool doReadUint32(uint32_t* value);
     bool doReadUint64(uint64_t* value);
     bool doReadNumber(double* number);
     PassRefPtr<BlobDataHandle> getOrCreateBlobDataHandle(const String& uuid, const String& type, long long size = -1);
-    bool doReadHmacKey(WebCryptoKeyAlgorithm&, WebCryptoKeyType&);
-    bool doReadAesKey(WebCryptoKeyAlgorithm&, WebCryptoKeyType&);
-    bool doReadRsaHashedKey(WebCryptoKeyAlgorithm&, WebCryptoKeyType&);
-    bool doReadEcKey(WebCryptoKeyAlgorithm&, WebCryptoKeyType&);
-    bool doReadAlgorithmId(WebCryptoAlgorithmId&);
-    bool doReadAsymmetricKeyType(WebCryptoKeyType&);
-    bool doReadNamedCurve(WebCryptoNamedCurve&);
-    bool doReadKeyUsages(WebCryptoKeyUsageMask& usages, bool& extractable);
 
 private:
     RefPtr<ScriptState> m_scriptState;
     const uint8_t* m_buffer;
     const unsigned m_length;
     unsigned m_position;
     uint32_t m_version;
     const WebBlobInfoArray* m_blobInfo;
     const BlobDataHandleMap& m_blobDataHandles;
 };
@@ skipping 20 matching lines @@
     virtual bool completeSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>*) override;
     virtual bool completeDenseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>*) override;
     virtual void pushObjectReference(const v8::Handle<v8::Value>&) override;
     virtual bool tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::Value>*) override;
     virtual bool tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::Value>*) override;
     virtual bool tryGetObjectFromObjectReference(uint32_t reference, v8::Handle<v8::Value>*) override;
     virtual uint32_t objectReferenceCount() override;
 
 protected:
     Reader& reader() { return m_reader; }
-    bool read(v8::Local<v8::Value>*);
+    virtual bool read(v8::Local<v8::Value>*);
 
 private:
     bool initializeObject(v8::Handle<v8::Object>, uint32_t numProperties, v8::Handle<v8::Value>*);
     bool doDeserialize();
     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);
     }
@@ skipping 11 matching lines @@
     ArrayBufferContentsArray* m_arrayBufferContents;
     Vector<v8::Handle<v8::Object> > m_arrayBuffers;
     uint32_t m_version;
 };
 
 } // namespace SerializedScriptValueInternal
 
 } // namespace blink
 
 #endif // ScriptValueSerializer_h