[webcrypto] Make KeyPair structured clonable.

Source/bindings/v8/SerializedScriptValue.cpp

Index: Source/bindings/v8/SerializedScriptValue.cpp
diff --git a/Source/bindings/v8/SerializedScriptValue.cpp b/Source/bindings/v8/SerializedScriptValue.cpp
index fefbc866b8a84f0a46b3effa9be025f069046230..8415eb0b6bbf12b7f0d871956fa68cadbe2699ab 100644
--- a/Source/bindings/v8/SerializedScriptValue.cpp
+++ b/Source/bindings/v8/SerializedScriptValue.cpp
@@ -37,6 +37,7 @@
 #include "V8FileList.h"
 #include "V8ImageData.h"
 #include "V8Key.h"
+#include "V8KeyPair.h"
 #include "V8MessagePort.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/V8Binding.h"
@@ -225,6 +226,7 @@ enum SerializationTag {
                         //       props = algorithmId:uint32_t, type:uint32_t, modulusLengthBits:uint32_t, publicExponentLength:uint32_t, publicExponent:byte[publicExponentLength]
                         //   If subtag=RsaHashedKeyTag:
                         //       props = <same as for RsaKeyTag>, hashId:uint32_t
+    CryptoKeyPairTag = 'k', // publicKey:CryptoKey, privateKey:CryptoKey
     ObjectReferenceTag = '^', // ref:uint32_t -> reference table[ref]
     GenerateFreshObjectTag = 'o', // -> empty object allocated an object ID and pushed onto the open stack (ref)
     GenerateFreshSparseArrayTag = 'a', // length:uint32_t -> empty array[length] allocated an object ID and pushed onto the open stack (ref)
@@ -506,9 +508,10 @@ public:
             doWriteUint32(blobIndices[i]);
     }
 
-    bool writeCryptoKey(const blink::WebCryptoKey& key)
+    bool writeCryptoKey(const blink::WebCryptoKey& key, bool includeTag)
     {
-        append(static_cast<uint8_t>(CryptoKeyTag));
+        if (includeTag)
+            append(static_cast<uint8_t>(CryptoKeyTag));
 
         switch (key.algorithm().paramsType()) {
         case blink::WebCryptoKeyAlgorithmParamsTypeAes:
@@ -537,6 +540,12 @@ public:
         return true;
     }
 
+    bool writeCryptoKeyPair(const blink::WebCryptoKey& publicKey, const blink::WebCryptoKey& privateKey)
+    {
+        append(static_cast<uint8_t>(CryptoKeyPairTag));
+        return writeCryptoKey(publicKey, false) && writeCryptoKey(privateKey, false);
+    }
+
     void writeArrayBuffer(const ArrayBuffer& arrayBuffer)
     {
         append(ArrayBufferTag);
@@ -1355,8 +1364,16 @@ private:
     {
         Key* key = V8Key::toNative(value.As<v8::Object>());
         if (!key)
-            return 0;
-        return m_writer.writeCryptoKey(key->key());
+            return false;
+        return m_writer.writeCryptoKey(key->key(), true);
+    }
+
+    bool writeCryptoKeyPair(v8::Handle<v8::Value> value)
+    {
+        KeyPair* keyPair = V8KeyPair::toNative(value.As<v8::Object>());
+        if (!keyPair)
+            return false;
+        return m_writer.writeCryptoKeyPair(keyPair->publicKey()->key(), keyPair->privateKey()->key());
     }
 
     void writeImageData(v8::Handle<v8::Value> value)
@@ -1576,6 +1593,9 @@ Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, Stat
         else if (V8Key::hasInstance(value, m_isolate)) {
             if (!writeCryptoKey(value))
                 return handleError(DataCloneError, "Couldn't serialize key data", next);
+        } else if (V8KeyPair::hasInstance(value, m_isolate)) {
+            if (!writeCryptoKeyPair(value))
+                return handleError(DataCloneError, "Couldn't serialize key data", next);
         } else if (V8ImageData::hasInstance(value, m_isolate))
             writeImageData(value);
         else if (value->IsRegExp())
@@ -1738,6 +1758,11 @@ public:
                 return false;
             creator.pushObjectReference(*value);
             break;
+        case CryptoKeyPairTag:
+            if (!readCryptoKeyPair(value))
+                return false;
+            creator.pushObjectReference(*value);
+            break;
         case ImageDataTag:
             if (!readImageData(value))
                 return false;
@@ -2231,6 +2256,16 @@ private:
 
     bool readCryptoKey(v8::Handle<v8::Value>* value)
     {
+        blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+        if (!readCryptoKey(key))
+            return false;
+
+        *value = toV8(Key::create(key), v8::Handle<v8::Object>(), m_isolate);
+        return true;
+    }
+
+    bool readCryptoKey(blink::WebCryptoKey& key)
+    {
         uint32_t rawKeyType;
         if (!doReadUint32(&rawKeyType))
             return false;
@@ -2274,13 +2309,25 @@ private:
         const uint8_t* keyData = m_buffer + m_position;
         m_position += keyDataLength;
 
-        blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
         if (!blink::Platform::current()->crypto()->deserializeKeyForClone(
             algorithm, type, extractable, usages, keyData, keyDataLength, key)) {
             return false;
         }
 
-        *value = toV8(Key::create(key), v8::Handle<v8::Object>(), m_isolate);
+        return true;
+    }
+
+    bool readCryptoKeyPair(v8::Handle<v8::Value>* value)
+    {
+        blink::WebCryptoKey publicKey = blink::WebCryptoKey::createNull();
+        blink::WebCryptoKey privateKey = blink::WebCryptoKey::createNull();
+
+        if (!readCryptoKey(publicKey) || publicKey.type() != blink::WebCryptoKeyTypePublic)
+            return false;
+        if (!readCryptoKey(privateKey) || privateKey.type() != blink::WebCryptoKeyTypePrivate)
+            return false;
+
+        *value = toV8(KeyPair::create(publicKey, privateKey), v8::Handle<v8::Object>(), m_isolate);
         return true;
     }