RTCPeerConnectionInterface.mm createNativeConfiguration and other clean-up.

talk/app/webrtc/objc/RTCPeerConnectionInterface.mm

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * 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 notice,
@@ skipping 15 matching lines @@
  */
 
 #import "talk/app/webrtc/objc/RTCPeerConnectionInterface+Internal.h"
 
 #import "talk/app/webrtc/objc/RTCEnumConverter.h"
 #import "talk/app/webrtc/objc/RTCICEServer+Internal.h"
 #import "talk/app/webrtc/objc/public/RTCLogging.h"
 
 #include <memory>
 
+#include "webrtc/base/rtccertificategenerator.h"
+
 @implementation RTCConfiguration
 
 @synthesize iceTransportsType = _iceTransportsType;
 @synthesize iceServers = _iceServers;
 @synthesize bundlePolicy = _bundlePolicy;
 @synthesize rtcpMuxPolicy = _rtcpMuxPolicy;
 @synthesize tcpCandidatePolicy = _tcpCandidatePolicy;
 @synthesize audioJitterBufferMaxPackets = _audioJitterBufferMaxPackets;
 @synthesize iceConnectionReceivingTimeout = _iceConnectionReceivingTimeout;
 @synthesize iceBackupCandidatePairPingInterval = _iceBackupCandidatePairPingInterval;
@@ skipping 30 matching lines @@
     _tcpCandidatePolicy = tcpCandidatePolicy;
     _audioJitterBufferMaxPackets = audioJitterBufferMaxPackets;
     _iceConnectionReceivingTimeout = iceConnectionReceivingTimeout;
     _iceBackupCandidatePairPingInterval = iceBackupCandidatePairPingInterval;
   }
   return self;
 }
 
 #pragma mark - Private
 
-- (webrtc::PeerConnectionInterface::RTCConfiguration)nativeConfiguration {
-  webrtc::PeerConnectionInterface::RTCConfiguration nativeConfig;
-  nativeConfig.type = [RTCEnumConverter nativeEnumForIceTransportsType:_iceTransportsType];
+- (webrtc::PeerConnectionInterface::RTCConfiguration *)
+    createNativeConfiguration {
+  std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration>
+      nativeConfig(new webrtc::PeerConnectionInterface::RTCConfiguration());
+  nativeConfig->type =
+      [RTCEnumConverter nativeEnumForIceTransportsType:_iceTransportsType];
   for (RTCICEServer *iceServer : _iceServers) {
-    nativeConfig.servers.push_back(iceServer.iceServer);
+    nativeConfig->servers.push_back(iceServer.iceServer);
   }
-  nativeConfig.bundle_policy = [RTCEnumConverter nativeEnumForBundlePolicy:_bundlePolicy];
-  nativeConfig.rtcp_mux_policy = [RTCEnumConverter nativeEnumForRtcpMuxPolicy:_rtcpMuxPolicy];
-  nativeConfig.tcp_candidate_policy =
+  nativeConfig->bundle_policy =
+      [RTCEnumConverter nativeEnumForBundlePolicy:_bundlePolicy];
+  nativeConfig->rtcp_mux_policy =
+      [RTCEnumConverter nativeEnumForRtcpMuxPolicy:_rtcpMuxPolicy];
+  nativeConfig->tcp_candidate_policy =
       [RTCEnumConverter nativeEnumForTcpCandidatePolicy:_tcpCandidatePolicy];
-  nativeConfig.audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets;
-  nativeConfig.ice_connection_receiving_timeout = _iceConnectionReceivingTimeout;
-  nativeConfig.ice_backup_candidate_pair_ping_interval = _iceBackupCandidatePairPingInterval;
-  if (_keyType == kRTCEncryptionKeyTypeECDSA) {
-    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.");
+  nativeConfig->audio_jitter_buffer_max_packets = _audioJitterBufferMaxPackets;
+  nativeConfig->ice_connection_receiving_timeout =
+      _iceConnectionReceivingTimeout;
+  nativeConfig->ice_backup_candidate_pair_ping_interval =
+      _iceBackupCandidatePairPingInterval;
+  rtc::KeyType keyType =
+      [[self class] nativeEncryptionKeyTypeForKeyType:_keyType];
+  if (keyType != rtc::KT_DEFAULT) {
+    rtc::scoped_refptr<rtc::RTCCertificate> certificate =
+        rtc::RTCCertificateGenerator::GenerateCertificate(
+            rtc::KeyParams(keyType), rtc::Optional<uint64_t>());
+    if (!certificate) {
+      RTCLogError(@"Failed to generate certificate.");
+      return nullptr;
     }
+    nativeConfig->certificates.push_back(certificate);
   }
-  return nativeConfig;
+  return nativeConfig.release();
+}
+
++ (rtc::KeyType)nativeEncryptionKeyTypeForKeyType:
+    (RTCEncryptionKeyType)keyType {
+  switch (keyType) {
+    case kRTCEncryptionKeyTypeRSA:
+      return rtc::KT_RSA;
+    case kRTCEncryptionKeyTypeECDSA:
+      return rtc::KT_ECDSA;
+  }
 }
 
 @end