Make ECDSA default for RTCPeerConnection

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 11 matching lines @@
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #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"
 
 @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;
+@synthesize keyType = _keyType;
 
 - (instancetype)init {
   if (self = [super init]) {
     // Copy defaults.
     webrtc::PeerConnectionInterface::RTCConfiguration config;
     _iceTransportsType = [RTCEnumConverter iceTransportsTypeForNativeEnum:config.type];
     _bundlePolicy = [RTCEnumConverter bundlePolicyForNativeEnum:config.bundle_policy];
     _rtcpMuxPolicy = [RTCEnumConverter rtcpMuxPolicyForNativeEnum:config.rtcp_mux_policy];
     _tcpCandidatePolicy =
         [RTCEnumConverter tcpCandidatePolicyForNativeEnum:config.tcp_candidate_policy];
     _audioJitterBufferMaxPackets = config.audio_jitter_buffer_max_packets;
     _iceConnectionReceivingTimeout = config.ice_connection_receiving_timeout;
     _iceBackupCandidatePairPingInterval = config.ice_backup_candidate_pair_ping_interval;
+    _keyType = kRTCEncryptionKeyTypeECDSA;
   }
   return self;
 }
 
 - (instancetype)initWithIceTransportsType:(RTCIceTransportsType)iceTransportsType
                              bundlePolicy:(RTCBundlePolicy)bundlePolicy
                             rtcpMuxPolicy:(RTCRtcpMuxPolicy)rtcpMuxPolicy
                        tcpCandidatePolicy:(RTCTcpCandidatePolicy)tcpCandidatePolicy
               audioJitterBufferMaxPackets:(int)audioJitterBufferMaxPackets
             iceConnectionReceivingTimeout:(int)iceConnectionReceivingTimeout
@@ skipping 18 matching lines @@
   for (RTCICEServer *iceServer : _iceServers) {
     nativeConfig.servers.push_back(iceServer.iceServer);
   }
   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) {
+    rtc::scoped_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.");
+    }
+  }
   return nativeConfig;
 }
 
 @end