RTCCertificateGeneratorInterface and RTCCertificateGeneratorStoreWrapper added.

webrtc/api/dtlsidentitystore.cc

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 13 matching lines @@
 const char kIdentityName[] = "WebRTC";
 
 namespace {
 
 enum {
   MSG_DESTROY,
   MSG_GENERATE_IDENTITY,
   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:
+  RTCCertificateStoreCallbackObserver(
+      const rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>& callback)
+      : callback_(callback) {}
+
+  void OnFailure(int error) override {

[tommi (sloooow) - chröme, 2016/05/24 18:03:40]

nit: make implementation of OnFailure and OnSuccess, private?

[hbos, 2016/05/24 18:34:01]

Done. Callback can also be private.

+    LOG(LS_WARNING) << "DtlsIdentityRequestObserver failure code: " << error;
+    Callback(nullptr);
+  }
+  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:
+  void Callback(rtc::scoped_refptr<rtc::RTCCertificate> certificate) {
+    if (certificate)
+      callback_->OnSuccess(certificate);
+    else
+      callback_->OnFailure();
+  }
+
+  rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback> callback_;
+};
+
 }  // namespace
 
 // This class runs on the worker thread to generate the identity. It's necessary
 // to separate this class from DtlsIdentityStore so that it can live on the
 // worker thread after DtlsIdentityStore is destroyed.
 class DtlsIdentityStoreImpl::WorkerTask : public sigslot::has_slots<>,
                                           public rtc::MessageHandler {
  public:
   WorkerTask(DtlsIdentityStoreImpl* store, rtc::KeyType key_type)
       : signaling_thread_(rtc::Thread::Current()),
@@ skipping 97 matching lines @@
 }
 
 bool DtlsIdentityStoreImpl::HasFreeIdentityForTesting(
     rtc::KeyType key_type) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   return request_info_[key_type].free_identity_.get() != nullptr;
 }
 
 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.
   if (observer.get()) {
     request_info_[key_type].request_observers_.push(observer);
 
     // Already have a free identity generated?
     if (request_info_[key_type].free_identity_.get()) {
       // Return identity async - post even though we are on |signaling_thread_|.
       LOG(LS_VERBOSE) << "Using a free DTLS identity.";
@@ skipping 59 matching lines @@
     if (worker_thread_ != signaling_thread_ && // Only do in background thread.
         key_type == rtc::KT_RSA &&             // Only necessary for RSA.
         !request_info_[key_type].free_identity_.get() &&
         request_info_[key_type].request_observers_.size() ==
             request_info_[key_type].gen_in_progress_counts_) {
       GenerateIdentity(key_type, nullptr);
     }
   }
 }
 
+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,
+      new rtc::RefCountedObject<RTCCertificateStoreCallbackObserver>(callback));
+}
+
 }  // namespace webrtc