RTCCertificate and RTCPeerConnection.generateCertificate added to JavaScript

content/renderer/media/peer_connection_identity_store.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/peer_connection_identity_store.h"
 
 #include "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/renderer/media/webrtc_identity_service.h"
 #include "content/renderer/render_thread_impl.h"
 
 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> {
  public:
   explicit RequestHandler(webrtc::DtlsIdentityRequestObserver* observer)
       : signaling_thread_(base::ThreadTaskRunnerHandle::Get()),
         observer_(observer) {}
 
   void RequestIdentityOnUIThread(const GURL& url,
                                  const GURL& first_party_for_cookies) {
     int request_id =
         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);
   }
 
  private:
   friend class base::RefCountedThreadSafe<RequestHandler>;
   ~RequestHandler() {
     DCHECK(!observer_.get());
   }
@@ skipping 21 matching lines @@
   }
 
   void EnsureReleaseObserverOnSignalingThread() {
     DCHECK(signaling_thread_->BelongsToCurrentThread());
     observer_ = nullptr;
   }
 
   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(
     const GURL& url,
     const GURL& first_party_for_cookies)
     : main_thread_(base::ThreadTaskRunnerHandle::Get()),
       url_(url),
       first_party_for_cookies_(first_party_for_cookies) {
   signaling_thread_.DetachFromThread();
   DCHECK(main_thread_.get());
 }
 
 PeerConnectionIdentityStore::~PeerConnectionIdentityStore() {
   // Typically destructed on libjingle's signaling thread.
 }
 
 void PeerConnectionIdentityStore::RequestIdentity(
     rtc::KeyType key_type,
     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