Ability to persist RTCCertificate in IndexedDB (enables cloning).

third_party/WebKit/Source/bindings/modules/v8/ScriptValueSerializerForModules.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 "bindings/modules/v8/ScriptValueSerializerForModules.h"
 
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
 #include "bindings/modules/v8/V8DOMFileSystem.h"
+#include "bindings/modules/v8/V8RTCCertificate.h"
 #include "modules/filesystem/DOMFileSystem.h"
+#include "modules/mediastream/RTCCertificate.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebRTCCertificate.h"
+#include "public/platform/WebRTCCertificateGenerator.h"
 
 namespace blink {
 
 enum CryptoKeyAlgorithmTag {
     AesCbcTag = 1,
     HmacTag = 2,
     RsaSsaPkcs1v1_5Tag = 3,
     // ID 4 was used by RsaEs, while still behind experimental flag.
     Sha1Tag = 5,
     Sha256Tag = 6,
@@ skipping 68 matching lines @@
 }
 
 bool ScriptValueSerializerForModules::writeCryptoKey(v8::Local<v8::Value> value)
 {
     CryptoKey* key = V8CryptoKey::toImpl(value.As<v8::Object>());
     if (!key)
         return false;
     return toSerializedScriptValueWriterForModules(writer()).writeCryptoKey(key->key());
 }
 
+ScriptValueSerializer::StateBase* ScriptValueSerializerForModules::writeRTCCertificate(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
+{
+    RTCCertificate* certificate = V8RTCCertificate::toImpl(value.As<v8::Object>());
+    if (!certificate)
+        return handleError(DataCloneError, "An RTCCertificate object could not be cloned.", next);
+    toSerializedScriptValueWriterForModules(writer()).writeRTCCertificate(*certificate);
+    return 0;
+}
+
 void SerializedScriptValueWriterForModules::writeDOMFileSystem(int type, const String& name, const String& url)
 {
     append(DOMFileSystemTag);
     doWriteUint32(type);
     doWriteWebCoreString(name);
     doWriteWebCoreString(url);
 }
 
 bool SerializedScriptValueWriterForModules::writeCryptoKey(const WebCryptoKey& key)
 {
@@ skipping 21 matching lines @@
 
     WebVector<uint8_t> keyData;
     if (!Platform::current()->crypto()->serializeKeyForClone(key, keyData))
         return false;
 
     doWriteUint32(keyData.size());
     append(keyData.data(), keyData.size());
     return true;
 }
 
+void SerializedScriptValueWriterForModules::writeRTCCertificate(const RTCCertificate& certificate)
+{
+    append(RTCCertificateTag);
+
+    WebRTCCertificatePEM pem = certificate.certificateShallowCopy()->toPEM();
+    doWriteWebCoreString(String(pem.privateKey().c_str()));
+    doWriteWebCoreString(String(pem.certificate().c_str()));
+}
+
 void SerializedScriptValueWriterForModules::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());
 }
 
@@ skipping 134 matching lines @@
         value |= UnwrapKeyUsage;
     if (usages & WebCryptoKeyUsageDeriveBits)
         value |= DeriveBitsUsage;
 
     doWriteUint32(value);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializerForModules::doSerializeValue(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     bool isDOMFileSystem = V8DOMFileSystem::hasInstance(value, isolate());
-    if (isDOMFileSystem || V8CryptoKey::hasInstance(value, isolate())) {
+    bool isCryptoKey = V8CryptoKey::hasInstance(value, isolate());
+    bool isRTCCertificate = V8RTCCertificate::hasInstance(value, isolate());
+    if (isDOMFileSystem || isCryptoKey || isRTCCertificate) {
         v8::Local<v8::Object> jsObject = value.As<v8::Object>();
         if (jsObject.IsEmpty())
             return handleError(DataCloneError, "An object could not be cloned.", next);
         greyObject(jsObject);
 
         if (isDOMFileSystem)
             return writeDOMFileSystem(value, next);
-
-        if (!writeCryptoKey(value))
-            return handleError(DataCloneError, "Couldn't serialize key data", next);
-        return 0;
+        if (isCryptoKey) {
+            if (!writeCryptoKey(value))
+                return handleError(DataCloneError, "Couldn't serialize key data", next);
+            return 0;
+        }
+        if (isRTCCertificate)
+            return writeRTCCertificate(value, next);
+        ASSERT_NOT_REACHED();
     }
     return ScriptValueSerializer::doSerializeValue(value, next);
 }
 
 bool SerializedScriptValueReaderForModules::read(v8::Local<v8::Value>* value, ScriptValueCompositeCreator& creator)
 {
     SerializationTag tag;
     if (!readTag(&tag))
         return false;
     switch (tag) {
     case DOMFileSystemTag:
         if (!readDOMFileSystem(value))
             return false;
         creator.pushObjectReference(*value);
         break;
     case CryptoKeyTag:
         if (!readCryptoKey(value))
             return false;
         creator.pushObjectReference(*value);
         break;
+    case RTCCertificateTag:
+        if (!readRTCCertificate(value))
+            return false;
+        creator.pushObjectReference(*value);
+        break;
     default:
         return SerializedScriptValueReader::readWithTag(tag, value, creator);
     }
     return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReaderForModules::readDOMFileSystem(v8::Local<v8::Value>* value)
 {
     uint32_t type;
     String name;
@@ skipping 59 matching lines @@
     WebCryptoKey key = WebCryptoKey::createNull();
     if (!Platform::current()->crypto()->deserializeKeyForClone(
         algorithm, type, extractable, usages, keyData, keyDataLength, key)) {
         return false;
     }
 
     *value = toV8(CryptoKey::create(key), getScriptState()->context()->Global(), isolate());
     return !value->IsEmpty();
 }
 
+bool SerializedScriptValueReaderForModules::readRTCCertificate(v8::Local<v8::Value>* value)
+{
+    String pemPrivateKey;
+    if (!readWebCoreString(&pemPrivateKey))
+        return false;
+    String pemCertificate;
+    if (!readWebCoreString(&pemCertificate))
+        return false;
+
+    OwnPtr<WebRTCCertificateGenerator> certificateGenerator = adoptPtr(
+        Platform::current()->createRTCCertificateGenerator());
+
+    std::unique_ptr<WebRTCCertificate> certificate(
+        certificateGenerator->fromPEM(
+            pemPrivateKey.utf8().data(),
+            pemCertificate.utf8().data()));
+    RTCCertificate* jsCertificate = new RTCCertificate(std::move(certificate));
+
+    *value = toV8(jsCertificate, getScriptState()->context()->Global(), isolate());
+    return !value->IsEmpty();
+}
+
 bool SerializedScriptValueReaderForModules::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;
@@ skipping 210 matching lines @@
     : ScriptValueDeserializer(reader, messagePorts, arrayBufferContents, imageBitmapContents)
 {
 }
 
 bool ScriptValueDeserializerForModules::read(v8::Local<v8::Value>* value)
 {
     return toSerializedScriptValueReaderForModules(reader()).read(value, *this);
 }
 
 } // namespace blink