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 107 matching lines @@
 using webrtc::VideoSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
 // Field trials initialization string
 static char *field_trials_init_string = NULL;
 
+// Passed to SSLIdentity::Generate, "WebRTC". Used for the certificates'
+// subject and issuer name.
+static const char kIdentityName[] = "WebRTC";

[jiayl2, 2015/08/31 19:47:42]

a minor issue, but can you move it to a header file shared with
dtlsidentitystore?

[AlexG, 2015/08/31 20:14:13]

Done.

+
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool vp8_hw_acceleration_enabled = true;
 #endif
 
 extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
   jint ret = InitGlobalJniVariables(jvm);
   if (ret < 0)
     return -1;
@@ skipping 1128 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");
+      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_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);
 
+  // Create ECDSA certificate.
+  if (JavaKeyTypeToNativeType(jni, j_key_type) == rtc::KT_ECDSA) {
+    scoped_ptr<rtc::SSLIdentity> ssl_identity(
+        rtc::SSLIdentity::Generate(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 323 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