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 75 matching lines @@
 #include "talk/app/webrtc/java/jni/androidvideocapturer_jni.h"
 #include "webrtc/modules/video_render/video_render_internal.h"
 #include "webrtc/system_wrappers/interface/logcat_trace_context.h"
 using webrtc::LogcatTraceContext;
 #endif
 
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 using rtc::scoped_ptr;
+using rtc::scoped_refptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInit;
 using webrtc::DataChannelInterface;
 using webrtc::DataChannelObserver;
 using webrtc::IceCandidateInterface;
 using webrtc::MediaConstraintsInterface;
@@ skipping 12 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;
 
+// ECSDA certificate
+static scoped_refptr<rtc::RTCCertificate> g_rtc_certificate;
+
 #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) {
+  LOG(LS_INFO) << "JNI_OnLoad";
   jint ret = InitGlobalJniVariables(jvm);
   if (ret < 0)
     return -1;
 
   CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
   LoadGlobalClassReferenceHolder();
 
+  scoped_ptr<rtc::SSLIdentity> ssl_identity(
+      rtc::SSLIdentity::Generate(std::string(), rtc::KT_ECDSA));
+  if (ssl_identity.get()) {
+    g_rtc_certificate = rtc::RTCCertificate::Create(ssl_identity.Pass());

[jiayl2, 2015/08/25 23:06:02]

If the app runs for days or months, the certificate may expire, assuming this
method is called on per app launch?

Also, there is the privacy side that some app may not want to reuse the
certificate across PeerConnection.

I think it'll be better to create a new certificate in createPeerConnection.

[AlexG, 2015/08/25 23:15:26]

ok. Should I call both rtc::SSLIdentity::Generate() and
rtc::RTCCertificate::Create() in createPeerConnection or SSLIdentity can be
generated in JNI_OnLoad()?

[AlexG, 2015/08/25 23:56:02]

Done.

+    LOG(LS_INFO) << "ECDSA certificate created.";
+  } else {
+    LOG(LS_WARNING) << "Failed to generate SSLIdentity.";
+  }
+
   return ret;
 }
 
 extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM *jvm, void *reserved) {
   FreeGlobalClassReferenceHolder();
   CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
 }
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
@@ skipping 1181 matching lines @@
   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);
+  if (g_rtc_certificate.get() != NULL)
+    rtc_config.certificates.push_back(g_rtc_certificate);
 
   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) {
@@ skipping 324 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