Turning FakeDtlsIdentityStore into FakeRTCCertificateGenerator.

webrtc/api/test/fakertccertificategenerator.h

 /*
  *  Copyright 2013 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.
  */
 
-#ifndef WEBRTC_API_TEST_FAKEDTLSIDENTITYSERVICE_H_
-#define WEBRTC_API_TEST_FAKEDTLSIDENTITYSERVICE_H_
+#ifndef WEBRTC_API_TEST_FAKERTCCERTIFICATEGENERATOR_H_
+#define WEBRTC_API_TEST_FAKERTCCERTIFICATEGENERATOR_H_
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "webrtc/api/dtlsidentitystore.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/base/rtccertificate.h"
 
 // RSA with mod size 1024, pub exp 0x10001.
@@ skipping 88 matching lines @@
         "-----BEGIN CERTIFICATE-----\n"
         "MIIBFDCBu6ADAgECAgkArZYdXMyJ5rswCgYIKoZIzj0EAwIwEDEOMAwGA1UEAwwF\n"
         "dGVzdDQwHhcNMTYwNTA5MDkxODA4WhcNMTYwNjA5MDkxODA4WjAQMQ4wDAYDVQQD\n"
         "DAV0ZXN0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN3ncWM8vJVRzBiC4Q9t\n"
         "IkzTd8/pHHkZjV0RnTT5nKSMkjzdV8MDK+alG4ZqE20EfSFz7vGQMJt6jpMzS03f\n"
         "nGswCgYIKoZIzj0EAwIDSAAwRQIgb/LBc8OtsC5lEDyjCP6M9xt5mwzUNrQBOFWZ\n"
         "1fE/g68CIQD7uoFfbiq6dTp8ZwzbwQ8jJf08KjriamqA9OW/4268Dw==\n"
         "-----END CERTIFICATE-----\n")
 };
 
-class FakeDtlsIdentityStore : public webrtc::DtlsIdentityStoreInterface,
-                              public rtc::MessageHandler {
+class FakeRTCCertificateGenerator
+    : public rtc::RTCCertificateGeneratorInterface,
+      public rtc::MessageHandler {
  public:
   typedef rtc::TypedMessageData<rtc::scoped_refptr<
-      webrtc::DtlsIdentityRequestObserver> > MessageData;
+      rtc::RTCCertificateGeneratorCallback> > MessageData;
 
-  FakeDtlsIdentityStore() : should_fail_(false) {}
+  FakeRTCCertificateGenerator() : should_fail_(false) {}
 
   void set_should_fail(bool should_fail) {
     should_fail_ = should_fail;
   }
 
   void use_original_key() { key_index_ = 0; }
   void use_alternate_key() { key_index_ = 1; }
 
-  void RequestIdentity(
+  void GenerateCertificateAsync(
       const rtc::KeyParams& key_params,
       const rtc::Optional<uint64_t>& expires_ms,
-      const rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver>&
-          observer) override {
+      const rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>&
+          callback) override {
     // The certificates are created from constant PEM strings and use its coded
     // expiration time, we do not support modifying it.
     RTC_DCHECK(!expires_ms);
     MessageData* msg = new MessageData(
-        rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver>(observer));
+        rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>(callback));
     uint32_t msg_id;
     // Only supports RSA-1024-0x10001 and ECDSA-P256.
     if (should_fail_) {
       msg_id = MSG_FAILURE;
     } else if (key_params.type() == rtc::KT_RSA) {
       RTC_DCHECK(key_params.rsa_params().mod_size == 1024 &&
                  key_params.rsa_params().pub_exp == 0x10001);
       msg_id = MSG_SUCCESS_RSA;
     } else {
       RTC_DCHECK(key_params.type() == rtc::KT_ECDSA &&
                  key_params.ec_curve() == rtc::EC_NIST_P256);
       msg_id = MSG_SUCCESS_ECDSA;
     }
     rtc::Thread::Current()->Post(this, msg_id, msg);
   }
 
   static rtc::scoped_refptr<rtc::RTCCertificate> GenerateCertificate() {
-    std::unique_ptr<rtc::SSLIdentity> identity;
     switch (rtc::KT_DEFAULT) {
     case rtc::KT_RSA:
-      identity.reset(
-          rtc::SSLIdentity::FromPEMStrings(kRsaPems[0].private_key(),
-                                           kRsaPems[0].certificate()));
-      break;
+      return rtc::RTCCertificate::FromPEM(kRsaPems[0]);
     case rtc::KT_ECDSA:
-      identity.reset(
-          rtc::SSLIdentity::FromPEMStrings(kEcdsaPems[0].private_key(),
-                                           kEcdsaPems[0].certificate()));
-      break;
+      return rtc::RTCCertificate::FromPEM(kEcdsaPems[0]);
     default:
       RTC_NOTREACHED();
+      return nullptr;
     }
-    return rtc::RTCCertificate::Create(std::move(identity));
   }
 
  private:
   enum {
     MSG_SUCCESS_RSA,
     MSG_SUCCESS_ECDSA,
     MSG_FAILURE,
   };
 
   const rtc::RTCCertificatePEM& get_pem(const rtc::KeyType& key_type) const {
@@ skipping 10 matching lines @@
   const std::string& get_key(const rtc::KeyType& key_type) const {
     return get_pem(key_type).private_key();
   }
   const std::string& get_cert(const rtc::KeyType& key_type) const {
     return get_pem(key_type).certificate();
   }
 
   // rtc::MessageHandler implementation.
   void OnMessage(rtc::Message* msg) override {
     MessageData* message_data = static_cast<MessageData*>(msg->pdata);
-    rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver> observer =
+    rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback> callback =
         message_data->data();
+    rtc::scoped_refptr<rtc::RTCCertificate> certificate;
     switch (msg->message_id) {
       case MSG_SUCCESS_RSA:
       case MSG_SUCCESS_ECDSA: {
         rtc::KeyType key_type =
             msg->message_id == MSG_SUCCESS_RSA ? rtc::KT_RSA : rtc::KT_ECDSA;
-        std::unique_ptr<rtc::SSLIdentity> identity(
-            rtc::SSLIdentity::FromPEMStrings(get_key(key_type),
-                                             get_cert(key_type)));
-        observer->OnSuccess(std::move(identity));
+        certificate = rtc::RTCCertificate::FromPEM(get_pem(key_type));
+        RTC_DCHECK(certificate);
+        callback->OnSuccess(certificate);
         break;
       }
       case MSG_FAILURE:
-        observer->OnFailure(0);
+        callback->OnFailure();
         break;
     }
     delete message_data;
   }
 
   bool should_fail_;
   int key_index_ = 0;
 };
 
-#endif  // WEBRTC_API_TEST_FAKEDTLSIDENTITYSERVICE_H_
+#endif  // WEBRTC_API_TEST_FAKERTCCERTIFICATEGENERATOR_H_