Handle RTCCertificate::fromPEM returning nullptr, with a unit test.

third_party/WebKit/Source/bindings/modules/v8/serialization/V8ScriptValueSerializerForModulesTest.cpp

 // Copyright 2016 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/serialization/V8ScriptValueSerializerForModules.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/ToV8.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 137 matching lines @@
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
 
   // Make a certificate with the existing key above.
   std::unique_ptr<WebRTCCertificateGenerator> certificateGenerator(
       Platform::current()->createRTCCertificateGenerator());
   std::unique_ptr<WebRTCCertificate> webCertificate =
       certificateGenerator->fromPEM(
           WebString::fromUTF8(kEcdsaPrivateKey, sizeof(kEcdsaPrivateKey)),
           WebString::fromUTF8(kEcdsaCertificate, sizeof(kEcdsaCertificate)));
+  ASSERT_TRUE(webCertificate);
   RTCCertificate* certificate = new RTCCertificate(std::move(webCertificate));
 
   // Round trip test.
   v8::Local<v8::Value> wrapper =
       toV8(certificate, scope.context()->Global(), scope.isolate());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8RTCCertificate::hasInstance(result, scope.isolate()));
   RTCCertificate* newCertificate =
       V8RTCCertificate::toImpl(result.As<v8::Object>());
   WebRTCCertificatePEM pem = newCertificate->certificate().toPEM();
@@ skipping 16 matching lines @@
   v8::Local<v8::Value> result =
       V8ScriptValueDeserializerForModules(scriptState, input).deserialize();
   ASSERT_TRUE(V8RTCCertificate::hasInstance(result, scope.isolate()));
   RTCCertificate* newCertificate =
       V8RTCCertificate::toImpl(result.As<v8::Object>());
   WebRTCCertificatePEM pem = newCertificate->certificate().toPEM();
   EXPECT_EQ(kEcdsaPrivateKey, pem.privateKey());
   EXPECT_EQ(kEcdsaCertificate, pem.certificate());
 }
 
+TEST(V8ScriptValueSerializerForModulesTest, DecodeInvalidRTCCertificate) {
+  ScopedEnableV8BasedStructuredClone enable;
+  V8TestingScope scope;
+
+  // This is valid, except that "private" is not a valid private key PEM and
+  // "certificate" is not a valid certificate PEM. This checks what happens if
+  // these fail validation inside WebRTC.
+  ScriptState* scriptState = scope.getScriptState();
+  RefPtr<SerializedScriptValue> input = serializedValue(
+      {0xff, 0x09, 0x3f, 0x00, 0x6b, 0x07, 'p', 'r', 'i', 'v', 'a', 't', 'e',
+       0x0b, 'c',  'e',  'r',  't',  'i',  'f', 'i', 'c', 'a', 't', 'e', 0x00});
+
+  // Decode test.
+  v8::Local<v8::Value> result =
+      V8ScriptValueDeserializerForModules(scriptState, input).deserialize();
+  EXPECT_TRUE(result->IsNull());
+}
+
 // A bunch of voodoo which allows the asynchronous WebCrypto operations to be
 // called synchronously, with the resulting JavaScript values extracted.
 
 using CryptoKeyPair = std::pair<CryptoKey*, CryptoKey*>;
 
 template <typename T>
 T convertCryptoResult(const ScriptValue&);
 template <>
 CryptoKey* convertCryptoResult<CryptoKey*>(const ScriptValue& value) {
   return V8CryptoKey::toImplWithTypeCheck(value.isolate(), value.v8Value());
@@ skipping 628 matching lines @@
   EXPECT_TRUE(
       V8ScriptValueDeserializerForModules(
           scriptState, serializedValue({0xff, 0x09, 0x3f, 0x00, 0x4b, 0x04,
                                         0x0d, 0x01, 0x80, 0x08, 0x03, 0x01}))
           .deserialize()
           ->IsNull());
 }
 
 }  // namespace
 }  // namespace blink