Add option to enable ECDSA key for Java API.

talk/app/webrtc/java/jni/peerconnection_jni.cc

 /*
  * libjingle
  * Copyright 2013 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 43 matching lines @@
 
 #include <jni.h>
 #undef JNIEXPORT
 #define JNIEXPORT __attribute__((visibility("default")))
 
 #include <limits>
 
 #include "talk/app/webrtc/java/jni/classreferenceholder.h"
 #include "talk/app/webrtc/java/jni/jni_helpers.h"
 #include "talk/app/webrtc/java/jni/native_handle_impl.h"
+#include "talk/app/webrtc/dtlsidentitystore.h"
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videorenderer.h"
 #include "talk/media/devices/videorendererfactory.h"
 #include "talk/media/webrtc/webrtcvideodecoderfactory.h"
 #include "talk/media/webrtc/webrtcvideoencoderfactory.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
@@ skipping 1192 matching lines @@
   if (enum_name == "ENABLED")
     return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
 
   if (enum_name == "DISABLED")
     return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
 
   CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
   return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
 }
 
+static rtc::KeyType JavaKeyTypeToNativeType(JNIEnv* jni, jobject j_key_type) {
+  std::string enum_name = GetJavaEnumName(
+      jni, "org/webrtc/PeerConnection$KeyType", j_key_type);
+
+  if (enum_name == "RSA")
+    return rtc::KT_RSA;
+  if (enum_name == "ECDSA")
+    return rtc::KT_ECDSA;
+
+  CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
+  return rtc::KT_ECDSA;
+}
+
 static void JavaIceServersToJsepIceServers(
     JNIEnv* jni, jobject j_ice_servers,
     PeerConnectionInterface::IceServers* ice_servers) {
   jclass list_class = GetObjectClass(jni, j_ice_servers);
   jmethodID iterator_id = GetMethodID(
       jni, list_class, "iterator", "()Ljava/util/Iterator;");
   jobject iterator = jni->CallObjectMethod(j_ice_servers, iterator_id);
   CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
   jmethodID iterator_has_next = GetMethodID(
       jni, GetObjectClass(jni, iterator), "hasNext", "()Z");
@@ skipping 52 matching lines @@
   jobject j_rtcp_mux_policy = GetObjectField(
       jni, j_rtc_config, j_rtcp_mux_policy_id);
 
   jfieldID j_tcp_candidate_policy_id = GetFieldID(
       jni, j_rtc_config_class, "tcpCandidatePolicy",
       "Lorg/webrtc/PeerConnection$TcpCandidatePolicy;");
   jobject j_tcp_candidate_policy = GetObjectField(
       jni, j_rtc_config, j_tcp_candidate_policy_id);
 
   jfieldID j_ice_servers_id = GetFieldID(
-      jni, j_rtc_config_class, "iceServers",
-      "Ljava/util/List;");
+      jni, j_rtc_config_class, "iceServers", "Ljava/util/List;");
   jobject j_ice_servers = GetObjectField(jni, j_rtc_config, j_ice_servers_id);
 
   jfieldID j_audio_jitter_buffer_max_packets_id =
       GetFieldID(jni, j_rtc_config_class, "audioJitterBufferMaxPackets", "I");
   jfieldID j_audio_jitter_buffer_fast_accelerate_id = GetFieldID(
       jni, j_rtc_config_class, "audioJitterBufferFastAccelerate", "Z");
 
   jfieldID j_ice_connection_receiving_timeout_id =
       GetFieldID(jni, j_rtc_config_class, "iceConnectionReceivingTimeout", "I");
 
+  jfieldID j_key_type_id = GetFieldID(jni, j_rtc_config_class, "keyType",
+      "Lorg/webrtc/PeerConnection$KeyType;");
+  jobject j_key_type = GetObjectField(jni, j_rtc_config, j_key_type_id);
+
   PeerConnectionInterface::RTCConfiguration rtc_config;
   rtc_config.type =
       JavaIceTransportsTypeToNativeType(jni, j_ice_transports_type);
   rtc_config.bundle_policy = JavaBundlePolicyToNativeType(jni, j_bundle_policy);
   rtc_config.rtcp_mux_policy =
       JavaRtcpMuxPolicyToNativeType(jni, j_rtcp_mux_policy);
   rtc_config.tcp_candidate_policy =
       JavaTcpCandidatePolicyToNativeType(jni, j_tcp_candidate_policy);
   JavaIceServersToJsepIceServers(jni, j_ice_servers, &rtc_config.servers);
   rtc_config.audio_jitter_buffer_max_packets =
       GetIntField(jni, j_rtc_config, j_audio_jitter_buffer_max_packets_id);
   rtc_config.audio_jitter_buffer_fast_accelerate = GetBooleanField(
       jni, j_rtc_config, j_audio_jitter_buffer_fast_accelerate_id);
   rtc_config.ice_connection_receiving_timeout =
       GetIntField(jni, j_rtc_config, j_ice_connection_receiving_timeout_id);
 
+  // Create ECDSA certificate.
+  if (JavaKeyTypeToNativeType(jni, j_key_type) == rtc::KT_ECDSA) {
+    scoped_ptr<rtc::SSLIdentity> ssl_identity(
+        rtc::SSLIdentity::Generate(webrtc::kIdentityName, rtc::KT_ECDSA));
+    if (ssl_identity.get()) {
+      rtc_config.certificates.push_back(
+          rtc::RTCCertificate::Create(ssl_identity.Pass()));
+      LOG(LS_INFO) << "ECDSA certificate created.";
+    } else {
+      // Failing to create certificate should not abort peer connection
+      // creation. Instead default encryption (currently RSA) will be used.
+      LOG(LS_WARNING) <<
+          "Failed to generate SSLIdentity. Default encryption will be used.";
+    }
+  }
+
   PCOJava* observer = reinterpret_cast<PCOJava*>(observer_p);
   observer->SetConstraints(new ConstraintsWrapper(jni, j_constraints));
   rtc::scoped_refptr<PeerConnectionInterface> pc(f->CreatePeerConnection(
       rtc_config, observer->constraints(), NULL, NULL, observer));
   return (jlong)pc.release();
 }
 
 static rtc::scoped_refptr<PeerConnectionInterface> ExtractNativePC(
     JNIEnv* jni, jobject j_pc) {
   jfieldID native_pc_id = GetFieldID(jni,
@@ skipping 316 matching lines @@
 }
 
 JOW(void, VideoTrack_nativeRemoveRenderer)(
     JNIEnv* jni, jclass,
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
   reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)->RemoveRenderer(
       reinterpret_cast<VideoRendererInterface*>(j_renderer_pointer));
 }
 
 }  // namespace webrtc_jni