RTCCertificateGeneratorInterface and RTCCertificateGeneratorStoreWrapper added.

webrtc/api/dtlsidentitystore.cc

Index: webrtc/api/dtlsidentitystore.cc
diff --git a/webrtc/api/dtlsidentitystore.cc b/webrtc/api/dtlsidentitystore.cc
index bdccc10c1b03469a5995a047aae2198a83ba861b..a683db2f94831953f4d66fd9fc16fe0b7c39b2f3 100644
--- a/webrtc/api/dtlsidentitystore.cc
+++ b/webrtc/api/dtlsidentitystore.cc
@@ -31,6 +31,63 @@ enum {
   MSG_GENERATE_IDENTITY_RESULT
 };
 
+// A |DtlsIdentityRequestObserver| that informs an
+// |RTCCertificateGeneratorCallback| of the result of an identity request. On
+// success, a certificate is created using the identity before passing it to
+// the callback.
+class RTCCertificateStoreCallbackObserver
+    : public webrtc::DtlsIdentityRequestObserver {
+ public:
+  static rtc::scoped_refptr<DtlsIdentityRequestObserver> Create(
+      const rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>&
+        callback) {
+    rtc::scoped_refptr<RTCCertificateStoreCallbackObserver> observer(
+        new rtc::RefCountedObject<RTCCertificateStoreCallbackObserver>(
+            callback));
+    observer->this_ = observer;
+    return observer;
+  }
+
+  void OnFailure(int error) override {
+    Callback(nullptr);

[hta-webrtc, 2016/05/23 13:50:38]

The error is lost to the world here. Should you at least DLOG it?

[hbos, 2016/05/24 08:49:43]

Done, LOG(LS_WARNING).

+  }
+  void OnSuccess(const std::string& der_cert,
+                 const std::string& der_private_key) override {
+    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());
+    std::unique_ptr<rtc::SSLIdentity> identity(
+        rtc::SSLIdentity::FromPEMStrings(pem_key, pem_cert));
+    OnSuccess(std::move(identity));
+  }
+  void OnSuccess(std::unique_ptr<rtc::SSLIdentity> identity) override {
+    Callback(rtc::RTCCertificate::Create(std::move(identity)));
+  }
+
+ protected:
+  RTCCertificateStoreCallbackObserver(
+      const rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>& callback)
+      : callback_(callback) {}
+
+  void Callback(rtc::scoped_refptr<rtc::RTCCertificate> certificate) {
+    if (certificate)
+      callback_->OnSuccess(certificate);
+    else
+      callback_->OnFailure();
+    // If |this_| is the last reference to this observer the following line
+    // leads to its destruction - do not touch member variables afterwards.
+    this_ = nullptr;
+  }
+
+  rtc::scoped_refptr<DtlsIdentityRequestObserver> this_;

[hta-webrtc, 2016/05/23 13:50:38]

can you call it something other than "this_"?
"prevent_garbage_collection_" would be my suggestion, "self_reference_ might be
another, but Tommi probably has a stronger opinion.

[hbos, 2016/05/24 08:49:43]

On second thought this self-referencing thing is completely unnecessary. It is
already referenced by the thread message handling. "this_" was a bug; if the
posting was aborted "this_ = nullptr;" would never happen and the circular
self-reference lead to a memory leak. Removed this_, problem solved.

+  rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback> callback_;
+};
+
 }  // namespace
 
 // This class runs on the worker thread to generate the identity. It's necessary
@@ -148,7 +205,7 @@ bool DtlsIdentityStoreImpl::HasFreeIdentityForTesting(
 
 void DtlsIdentityStoreImpl::GenerateIdentity(
     rtc::KeyType key_type,
-    const rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver>& observer) {
+    const rtc::scoped_refptr<DtlsIdentityRequestObserver>& observer) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   // Enqueue observer to be informed when generation of |key_type| is completed.
@@ -228,4 +285,20 @@ void DtlsIdentityStoreImpl::OnIdentityGenerated(
   }
 }
 
+RTCCertificateGeneratorStoreWrapper::RTCCertificateGeneratorStoreWrapper(
+    std::unique_ptr<DtlsIdentityStoreInterface> store)
+    : store_(std::move(store)) {
+  RTC_DCHECK(store_);
+}
+
+void RTCCertificateGeneratorStoreWrapper::GenerateCertificateAsync(
+    const rtc::KeyParams& key_params,
+    const rtc::Optional<uint64_t>& expires_ms,
+    const rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>& callback) {
+  store_->RequestIdentity(
+      key_params,
+      expires_ms,
+      RTCCertificateStoreCallbackObserver::Create(callback));
+}
+
 }  // namespace webrtc