JNI+mm: Generate certificate if non-default key type is specified.

webrtc/sdk/objc/Framework/Classes/RTCConfiguration.mm

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #import "RTCConfiguration+Private.h"
 
 #include <memory>
 
 #import "RTCIceServer+Private.h"
 #import "WebRTC/RTCLogging.h"
 
+#include "webrtc/base/rtccertificategenerator.h"
 #include "webrtc/base/sslidentity.h"
 
 @implementation RTCConfiguration
 
 @synthesize iceServers = _iceServers;
 @synthesize iceTransportPolicy = _iceTransportPolicy;
 @synthesize bundlePolicy = _bundlePolicy;
 @synthesize rtcpMuxPolicy = _rtcpMuxPolicy;
 @synthesize tcpCandidatePolicy = _tcpCandidatePolicy;
 @synthesize audioJitterBufferMaxPackets = _audioJitterBufferMaxPackets;
@@ skipping 51 matching lines @@
       [[self class] nativeBundlePolicyForPolicy:_bundlePolicy];
   nativeConfig.rtcp_mux_policy =
       [[self class] nativeRtcpMuxPolicyForPolicy:_rtcpMuxPolicy];
   nativeConfig.tcp_candidate_policy =
       [[self class] nativeTcpCandidatePolicyForPolicy:_tcpCandidatePolicy];
   nativeConfig.audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets;
   nativeConfig.ice_connection_receiving_timeout =
       _iceConnectionReceivingTimeout;
   nativeConfig.ice_backup_candidate_pair_ping_interval =
       _iceBackupCandidatePairPingInterval;
-  if (_keyType == RTCEncryptionKeyTypeECDSA) {
-    std::unique_ptr<rtc::SSLIdentity> identity(
-        rtc::SSLIdentity::Generate(webrtc::kIdentityName, rtc::KT_ECDSA));
-    if (identity) {
-      nativeConfig.certificates.push_back(
-          rtc::RTCCertificate::Create(std::move(identity)));
-    } else {
-      RTCLogWarning(@"Failed to generate ECDSA identity. RSA will be used.");
-    }
+  rtc::KeyType keyType =
+      [[self class] nativeEncryptionKeyTypeForKeyType:_keyType];
+  // Generate non-default certificate.
+  if (keyType != rtc::KT_DEFAULT) {
+    rtc::scoped_refptr<rtc::RTCCertificate> certificate =
+        rtc::RTCCertificateGenerator::GenerateCertificate(
+            rtc::KeyParams(keyType), rtc::Optional<uint64_t>());
+    RTC_CHECK(certificate);

[hbos, 2016/05/12 08:27:08]

Here I still crash though. Since it is converting to the C++ version of a
configuration and it fails, surrounding code does not handle it (like null is
being handled in the java case):
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libjin...
In this case handling failure without crashing would be a lot of work.

It is my understanding that it failing is more of a theoretical scenario anyway,
like if you run out of memory, or something incredibly rare happens, I think
crashing is fine.

Our test code CHECK that certificates are generated all the time and they don't
fail.

[hbos, 2016/05/12 08:39:08]

Wait let me see if I can make setConfiguration return false and if that code
path already covers failure.

+    nativeConfig.certificates.push_back(certificate);
   }
 
   return nativeConfig;
 }
 
 + (webrtc::PeerConnectionInterface::IceTransportsType)
     nativeTransportsTypeForTransportPolicy:(RTCIceTransportPolicy)policy {
   switch (policy) {
     case RTCIceTransportPolicyNone:
       return webrtc::PeerConnectionInterface::kNone;
@@ skipping 100 matching lines @@
 + (webrtc::PeerConnectionInterface::TcpCandidatePolicy)
     nativeTcpCandidatePolicyForPolicy:(RTCTcpCandidatePolicy)policy {
   switch (policy) {
     case RTCTcpCandidatePolicyEnabled:
       return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled;
     case RTCTcpCandidatePolicyDisabled:
       return webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled;
   }
 }
 
++ (rtc::KeyType)nativeEncryptionKeyTypeForKeyType:
+    (RTCEncryptionKeyType)keyType {
+  switch (keyType) {
+    case RTCEncryptionKeyTypeRSA:
+      return rtc::KT_RSA;
+    case RTCEncryptionKeyTypeECDSA:
+      return rtc::KT_ECDSA;
+  }
+}
+
 + (RTCTcpCandidatePolicy)tcpCandidatePolicyForNativePolicy:
     (webrtc::PeerConnectionInterface::TcpCandidatePolicy)nativePolicy {
   switch (nativePolicy) {
     case webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled:
       return RTCTcpCandidatePolicyEnabled;
     case webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled:
       return RTCTcpCandidatePolicyDisabled;
   }
 }
 
 + (NSString *)stringForTcpCandidatePolicy:(RTCTcpCandidatePolicy)policy {
   switch (policy) {
     case RTCTcpCandidatePolicyEnabled:
       return @"TCP_ENABLED";
     case RTCTcpCandidatePolicyDisabled:
       return @"TCP_DISABLED";
   }
 }
 
 @end