RTCCertificate and RTCPeerConnection.generateCertificate added to JavaScript

content/renderer/media/peer_connection_identity_store.cc

Index: content/renderer/media/peer_connection_identity_store.cc
diff --git a/content/renderer/media/peer_connection_identity_store.cc b/content/renderer/media/peer_connection_identity_store.cc
index 444006ac656acb72affc09b549d9b315174c572b..50b15f067bbe20ba58bd1884ac95eb417b5fa704 100644
--- a/content/renderer/media/peer_connection_identity_store.cc
+++ b/content/renderer/media/peer_connection_identity_store.cc
@@ -11,6 +11,8 @@
 
 namespace content {
 namespace {
+const char kIdentityName[] = "WebRTC";
+
 // Bridges identity requests between the main render thread and libjingle's
 // signaling thread.
 class RequestHandler : public base::RefCountedThreadSafe<RequestHandler> {
@@ -25,7 +27,7 @@ class RequestHandler : public base::RefCountedThreadSafe<RequestHandler> {
         RenderThreadImpl::current()
             ->get_webrtc_identity_service()
             ->RequestIdentity(
-                url, first_party_for_cookies, "WebRTC", "WebRTC",
+                url, first_party_for_cookies, kIdentityName, kIdentityName,
                 base::Bind(&RequestHandler::OnIdentityReady, this),
                 base::Bind(&RequestHandler::OnRequestFailed, this));
     DCHECK_NE(request_id, 0);
@@ -67,6 +69,21 @@ class RequestHandler : public base::RefCountedThreadSafe<RequestHandler> {
   const scoped_refptr<base::SingleThreadTaskRunner> signaling_thread_;
   scoped_refptr<webrtc::DtlsIdentityRequestObserver> observer_;
 };
+
+// PeerConnectionIdentityStore::RequestIdentity helper class.
+// Used to invokes |observer|->OnSuccess in a PostTask.
+class ObserverOnSuccessCaller
+    : public base::RefCountedThreadSafe<ObserverOnSuccessCaller> {
+ public:
+  void CallObserverOnSuccess(
+      rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver> observer,
+      rtc::SSLIdentity* identity) {
+    observer->OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity>(identity).Pass());
+  }
+ private:
+  friend class base::RefCountedThreadSafe<ObserverOnSuccessCaller>;
+  ~ObserverOnSuccessCaller() {}
+};
 }  // namespace
 
 PeerConnectionIdentityStore::PeerConnectionIdentityStore(
@@ -88,14 +105,39 @@ void PeerConnectionIdentityStore::RequestIdentity(
     const rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver>& observer) {
   DCHECK(signaling_thread_.CalledOnValidThread());
   DCHECK(observer);
-  // This store only supports RSA.
-  DCHECK_EQ(key_type, rtc::KT_RSA);
-
-  scoped_refptr<RequestHandler> handler(new RequestHandler(observer));
-  main_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&RequestHandler::RequestIdentityOnUIThread, handler, url_,
-                 first_party_for_cookies_));
+
+  // TODO(hbos): Use modulus length parameter when KeyType is parameterized.
+  if (key_type == rtc::KT_RSA) {
+    // Use Chromium identity generation code for RSA.
+    scoped_refptr<RequestHandler> handler(new RequestHandler(observer));
+    main_thread_->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestHandler::RequestIdentityOnUIThread, handler, url_,
+                   first_party_for_cookies_));
+  } else {
+    // Use WebRTC identity generation code for non-RSA.
+    rtc::SSLIdentity* identity = rtc::SSLIdentity::Generate(kIdentityName,
+                                                            key_type);
+
+    scoped_refptr<base::SingleThreadTaskRunner> signaling_thread =
+        base::ThreadTaskRunnerHandle::Get();
+
+    // Invoke |observer| callbacks asynchronously. The callbacks of
+    // DtlsIdentityStoreInterface implementations have to be async.
+    if (identity) {
+      // Async call to observer->OnSuccess.
+      // Helper class necessary because OnSuccess takes a scoped_ptr argument
+      // and scoped_ptrs can't be passed with = operator, have to use .Pass().
+      signaling_thread->PostTask(FROM_HERE,
+          base::Bind(&ObserverOnSuccessCaller::CallObserverOnSuccess,
+                     new ObserverOnSuccessCaller(), observer, identity));
+    } else {
+      // Async call to observer->OnFailure.
+      signaling_thread->PostTask(FROM_HERE,
+          base::Bind(&webrtc::DtlsIdentityRequestObserver::OnFailure,
+                     observer, 0));
+    }
+  }
 }
 
 }  // namespace content