RTCPeerConnection.generateCertificate: Optionally specify expiration.

third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 654 matching lines @@
     AlgorithmError error;
     if (!normalizeAlgorithm(keygenAlgorithm, WebCryptoOperationGenerateKey, cryptoAlgorithm, &error)) {
         // Reject generateCertificate with the same error as was produced by WebCrypto.
         // |result| is garbage collected, no need to delete.
         CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
         ScriptPromise promise = result->promise();
         result->completeWithError(error.errorType, error.errorDetails);
         return promise;
     }
 
+    // Check if |keygenAlgorithm| contains the optional DOMTimeStamp |expires| attribute.
+    Nullable<DOMTimeStamp> expires;
+    if (keygenAlgorithm.isDictionary()) {
+        Dictionary keygenAlgorithmDict = keygenAlgorithm.getAsDictionary();
+        if (keygenAlgorithmDict.hasProperty("expires")) {
+            v8::Local<v8::Value> expiresValue;
+            keygenAlgorithmDict.get("expires", expiresValue);
+            if (expiresValue->IsNumber()) {
+                double expiresDouble = expiresValue->ToNumber(scriptState->isolate()->GetCurrentContext()).ToLocalChecked()->Value();
+                if (expiresDouble >= 0) {
+                    expires.set(static_cast<DOMTimeStamp>(expiresDouble));
+                }
+            }
+        }
+    }
+
     // Convert from WebCrypto representation to recognized WebRTCKeyParams. WebRTC supports a small subset of what are valid AlgorithmIdentifiers.
     const char* unsupportedParamsString = "The 1st argument provided is an AlgorithmIdentifier with a supported algorithm name, but the parameters are not supported.";
     Nullable<WebRTCKeyParams> keyParams;
     switch (cryptoAlgorithm.id()) {
     case WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
         // name: "RSASSA-PKCS1-v1_5"
         unsigned publicExponent;
         // "publicExponent" must fit in an unsigned int. The only recognized "hash" is "SHA-256".
         if (cryptoAlgorithm.rsaHashedKeyGenParams()->convertPublicExponentToUnsigned(publicExponent)
             && cryptoAlgorithm.rsaHashedKeyGenParams()->hash().id() == WebCryptoAlgorithmIdSha256) {
@@ skipping 26 matching lines @@
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, unsupportedParamsString));
     }
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     std::unique_ptr<WebRTCCertificateObserver> certificateObserver(WebRTCCertificateObserver::create(resolver));
 
     // Generate certificate. The |certificateObserver| will resolve the promise asynchronously upon completion.
     // The observer will manage its own destruction as well as the resolver's destruction.
-    certificateGenerator->generateCertificate(
-        keyParams.get(),
-        toDocument(scriptState->getExecutionContext())->url(),
-        toDocument(scriptState->getExecutionContext())->firstPartyForCookies(),
-        std::move(certificateObserver));
+    if (expires.isNull()) {
+        certificateGenerator->generateCertificate(
+            keyParams.get(),
+            toDocument(scriptState->getExecutionContext())->url(),
+            toDocument(scriptState->getExecutionContext())->firstPartyForCookies(),
+            std::move(certificateObserver));
+    } else {
+        certificateGenerator->generateCertificateWithExpiration(
+            keyParams.get(),
+            toDocument(scriptState->getExecutionContext())->url(),
+            toDocument(scriptState->getExecutionContext())->firstPartyForCookies(),
+            expires.get(),
+            std::move(certificateObserver));
+    }
 
     return promise;
 }
 
 ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, const RTCIceCandidateInitOrRTCIceCandidate& candidate)
 {
     if (m_signalingState == SignalingStateClosed)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
     if (isIceCandidateMissingSdp(candidate))
@@ skipping 439 matching lines @@
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dispatchScheduledEventRunner);
     visitor->trace(m_scheduledEvents);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink