RTCCertificate and RTCPeerConnection.generateCertificate added to JavaScript

content/renderer/media/rtc_certificate_generator.cc

+// Copyright (c) 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/rtc_certificate_generator.h"
+
+#include "content/renderer/media/peer_connection_identity_store.h"
+#include "content/renderer/media/rtc_certificate.h"
+#include "third_party/webrtc/base/rtccertificate.h"
+#include "url/gurl.h"
+
+namespace content {
+namespace {
+
+class RTCCertificateIdentityObserver
+    : public webrtc::DtlsIdentityRequestObserver {
+ public:
+  RTCCertificateIdentityObserver(
+      blink::WebRTCKeyType key_type,
+      webrtc::DtlsIdentityStoreInterface* store,
+      blink::WebCallbacks<blink::WebRTCCertificate*, void>* observer)
+      : key_type_(key_type), store_(store), observer_(observer) {
+  }
+
+  ~RTCCertificateIdentityObserver() override {
+  }
+
+  void Init(rtc::scoped_refptr<RTCCertificateIdentityObserver> self) {
+    this_ = self;
+  }
+
+ private:
+  void OnFailure(int error) override {
+    DCHECK(this_) << "Not initialized.";
+    observer_->onError();
+    // Stop protecting against destruction. This could result in "delete this".
+    this_ = nullptr;
+  }
+
+  void OnSuccess(const std::string& der_cert,
+                 const std::string& der_private_key) override {
+    DCHECK(this_) << "Not initialized.";
+    std::string pem_cert = rtc::SSLIdentity::DerToPem(
+        rtc::kPemTypeCertificate,
+        reinterpret_cast<const unsigned char*>(der_cert.data()),
+        der_cert.length());
+    std::string pem_key = rtc::SSLIdentity::DerToPem(
+        rtc::kPemTypeRsaPrivateKey,
+        reinterpret_cast<const unsigned char*>(der_private_key.data()),
+        der_private_key.length());
+    rtc::scoped_ptr<rtc::SSLIdentity> identity(
+        rtc::SSLIdentity::FromPEMStrings(pem_key, pem_cert));
+    OnSuccess(identity.Pass());
+  }
+
+  void OnSuccess(rtc::scoped_ptr<rtc::SSLIdentity> identity) override {
+    DCHECK(this_) << "Not initialized.";
+    rtc::scoped_refptr<rtc::RTCCertificate> certificate =
+        rtc::RTCCertificate::Create(identity.Pass());
+    observer_->onSuccess(new RTCCertificate(key_type_, certificate));
+    // Stop protecting against destruction. This could result in "delete this".
+    this_ = nullptr;
+  }
+
+  rtc::scoped_refptr<RTCCertificateIdentityObserver> this_;
+  blink::WebRTCKeyType key_type_;
+  rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> store_;
+  blink::WebCallbacks<blink::WebRTCCertificate*, void>* observer_;
+};
+
+}  // anonymous namespace
+
+void RTCCertificateGenerator::generateCertificate(
+    const blink::WebRTCKeyType& keyType,
+    const blink::WebURL& url,
+    const blink::WebURL& firstPartyForCookies,
+    blink::WebCallbacks<blink::WebRTCCertificate*, void>* observer) {
+  // TODO(hbos): Update conversion when rtc::KeyType has been updated.
+  rtc::KeyType rtc_key_type = rtc::IntKeyTypeFamilyToKeyType(
+      static_cast<int>(keyType.family()));
+
+  content::PeerConnectionIdentityStore* store =
+      new content::PeerConnectionIdentityStore(url, firstPartyForCookies);
+
+  rtc::scoped_refptr<RTCCertificateIdentityObserver> identity_observer(
+      new rtc::RefCountedObject<RTCCertificateIdentityObserver>(
+          keyType, store, observer));
+  identity_observer->Init(identity_observer);
+  store->RequestIdentity(rtc_key_type, identity_observer);
+}
+
+}  // namespace content