Added DtlsCertificate, a ref counted object owning an SSLIdentity

webrtc/base/sslstreamadapter_unittest.cc

 /*
  *  Copyright 2011 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 147 matching lines @@
 
 static const int kFifoBufferSize = 4096;
 
 class SSLStreamAdapterTestBase : public testing::Test,
                                  public sigslot::has_slots<> {
  public:
   SSLStreamAdapterTestBase(const std::string& client_cert_pem,
                            const std::string& client_private_key_pem,
                            bool dtls,
                            rtc::KeyType client_key_type = rtc::KT_DEFAULT,
-                           rtc::KeyType server_key_type = rtc::KT_DEFAULT)
-      : client_buffer_(kFifoBufferSize),
-        server_buffer_(kFifoBufferSize),
-        client_stream_(
-            new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_)),
-        server_stream_(
-            new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_)),
-        client_ssl_(rtc::SSLStreamAdapter::Create(client_stream_)),
-        server_ssl_(rtc::SSLStreamAdapter::Create(server_stream_)),
-        client_identity_(NULL),
-        server_identity_(NULL),
-        delay_(0),
-        mtu_(1460),
-        loss_(0),
-        lose_first_packet_(false),
-        damage_(false),
-        dtls_(dtls),
-        handshake_wait_(5000),
-        identities_set_(false) {
+                           rtc::KeyType server_key_type = rtc::KT_DEFAULT) :

[tommi (sloooow) - chröme, 2015/08/18 14:49:35]

nit: no need to change this

+      client_buffer_(kFifoBufferSize),
+      server_buffer_(kFifoBufferSize),
+      client_stream_(
+          new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_)),
+      server_stream_(
+          new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_)),
+      client_ssl_(rtc::SSLStreamAdapter::Create(client_stream_)),
+      server_ssl_(rtc::SSLStreamAdapter::Create(server_stream_)),
+      delay_(0),
+      mtu_(1460),
+      loss_(0),
+      lose_first_packet_(false),
+      damage_(false),
+      dtls_(dtls),
+      handshake_wait_(5000),
+      identities_set_(false) {
     // Set use of the test RNG to get predictable loss patterns.
     rtc::SetRandomTestMode(true);
 
     // Set up the slots
     client_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
     server_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
 
     if (!client_cert_pem.empty() && !client_private_key_pem.empty()) {
-      client_identity_ = rtc::SSLIdentity::FromPEMStrings(
-          client_private_key_pem, client_cert_pem);
+      client_certificate_ = webrtc::DtlsCertificate::Create(
+          rtc::scoped_ptr<rtc::SSLIdentity>(
+              rtc::SSLIdentity::FromPEMStrings(client_private_key_pem,
+                                               client_cert_pem)).Pass());
     } else {
-      client_identity_ = rtc::SSLIdentity::Generate("client", client_key_type);
+      client_certificate_ = webrtc::DtlsCertificate::Create(
+          rtc::scoped_ptr<rtc::SSLIdentity>(
+              rtc::SSLIdentity::Generate("client", client_key_type)).Pass());
     }
-    server_identity_ = rtc::SSLIdentity::Generate("server", server_key_type);
+    server_certificate_ = webrtc::DtlsCertificate::Create(
+        rtc::scoped_ptr<rtc::SSLIdentity>(
+            rtc::SSLIdentity::Generate("server", server_key_type)).Pass());
 
-    client_ssl_->SetIdentity(client_identity_);
-    server_ssl_->SetIdentity(server_identity_);
+    client_ssl_->SetCertificate(client_certificate_);
+    server_ssl_->SetCertificate(server_certificate_);
   }
 
   ~SSLStreamAdapterTestBase() {
     // Put it back for the next test.
     rtc::SetRandomTestMode(false);
   }
 
   // Recreate the client/server identities with the specified validity period.
   // |not_before| and |not_after| are offsets from the current time in number
   // of seconds.
   void ResetIdentitiesWithValidity(int not_before, int not_after) {
     client_stream_ =
         new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_);
     server_stream_ =
         new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_);
 
     client_ssl_.reset(rtc::SSLStreamAdapter::Create(client_stream_));
     server_ssl_.reset(rtc::SSLStreamAdapter::Create(server_stream_));
 
     client_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
     server_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
 
     rtc::SSLIdentityParams client_params;
     client_params.common_name = "client";
     client_params.not_before = not_before;
     client_params.not_after = not_after;
     client_params.key_type = rtc::KT_DEFAULT;
-    client_identity_ = rtc::SSLIdentity::GenerateForTest(client_params);
+    client_certificate_ = webrtc::DtlsCertificate::Create(
+        rtc::scoped_ptr<rtc::SSLIdentity>(
+            rtc::SSLIdentity::GenerateForTest(client_params)).Pass());
 
     rtc::SSLIdentityParams server_params;
     server_params.common_name = "server";
     server_params.not_before = not_before;
     server_params.not_after = not_after;
     server_params.key_type = rtc::KT_DEFAULT;
-    server_identity_ = rtc::SSLIdentity::GenerateForTest(server_params);
+    server_certificate_ = webrtc::DtlsCertificate::Create(
+        rtc::scoped_ptr<rtc::SSLIdentity>(
+            rtc::SSLIdentity::GenerateForTest(server_params)).Pass());
 
-    client_ssl_->SetIdentity(client_identity_);
-    server_ssl_->SetIdentity(server_identity_);
+    client_ssl_->SetCertificate(client_certificate_);
+    server_ssl_->SetCertificate(server_certificate_);
   }
 
   virtual void OnEvent(rtc::StreamInterface *stream, int sig, int err) {
     LOG(LS_INFO) << "SSLStreamAdapterTestBase::OnEvent sig=" << sig;
 
     if (sig & rtc::SE_READ) {
       ReadData(stream);
     }
 
     if ((stream == client_ssl_.get()) && (sig & rtc::SE_WRITE)) {
       WriteData();
     }
   }
 
   void SetPeerIdentitiesByDigest(bool correct) {
     unsigned char digest[20];
     size_t digest_len;
     bool rv;
 
     LOG(LS_INFO) << "Setting peer identities by digest";
 
-    rv = server_identity_->certificate().ComputeDigest(rtc::DIGEST_SHA_1,
-                                                       digest, 20,
-                                                       &digest_len);
+    rv = server_certificate_->identity()->certificate().ComputeDigest(
+        rtc::DIGEST_SHA_1, digest, 20, &digest_len);
     ASSERT_TRUE(rv);
     if (!correct) {
       LOG(LS_INFO) << "Setting bogus digest for server cert";
       digest[0]++;
     }
     rv = client_ssl_->SetPeerCertificateDigest(rtc::DIGEST_SHA_1, digest,
                                                digest_len);
     ASSERT_TRUE(rv);
 
 
-    rv = client_identity_->certificate().ComputeDigest(rtc::DIGEST_SHA_1,
-                                                       digest, 20, &digest_len);
+    rv = client_certificate_->identity()->certificate().ComputeDigest(
+        rtc::DIGEST_SHA_1, digest, 20, &digest_len);
     ASSERT_TRUE(rv);
     if (!correct) {
       LOG(LS_INFO) << "Setting bogus digest for client cert";
       digest[0]++;
     }
     rv = server_ssl_->SetPeerCertificateDigest(rtc::DIGEST_SHA_1, digest,
                                                digest_len);
     ASSERT_TRUE(rv);
 
     identities_set_ = true;
@@ skipping 153 matching lines @@
   virtual void ReadData(rtc::StreamInterface *stream) = 0;
   virtual void TestTransfer(int size) = 0;
 
  protected:
   rtc::FifoBuffer client_buffer_;
   rtc::FifoBuffer server_buffer_;
   SSLDummyStream *client_stream_;  // freed by client_ssl_ destructor
   SSLDummyStream *server_stream_;  // freed by server_ssl_ destructor
   rtc::scoped_ptr<rtc::SSLStreamAdapter> client_ssl_;
   rtc::scoped_ptr<rtc::SSLStreamAdapter> server_ssl_;
-  rtc::SSLIdentity *client_identity_;  // freed by client_ssl_ destructor
-  rtc::SSLIdentity *server_identity_;  // freed by server_ssl_ destructor
+  rtc::scoped_refptr<webrtc::DtlsCertificate> client_certificate_;
+  rtc::scoped_refptr<webrtc::DtlsCertificate> server_certificate_;
   int delay_;
   size_t mtu_;
   int loss_;
   bool lose_first_packet_;
   bool damage_;
   bool dtls_;
   int handshake_wait_;
   bool identities_set_;
 };
 
@@ skipping 588 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(SSLStreamAdapterTestsTLS,
                         SSLStreamAdapterTestTLS,
                         Combine(Values(rtc::KT_RSA, rtc::KT_ECDSA),
                                 Values(rtc::KT_RSA, rtc::KT_ECDSA)));
 INSTANTIATE_TEST_CASE_P(SSLStreamAdapterTestsDTLS,
                         SSLStreamAdapterTestDTLS,
                         Combine(Values(rtc::KT_RSA, rtc::KT_ECDSA),
                                 Values(rtc::KT_RSA, rtc::KT_ECDSA)));