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 148 matching lines @@
   SSLStreamAdapterTestBase(const std::string& client_cert_pem,
                            const std::string& client_private_key_pem,
                            bool dtls) :
       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) {
     // 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_certificate_ = webrtc::DtlsCertificate::Create(
+          rtc::scoped_ptr<rtc::SSLIdentity>(
+              rtc::SSLIdentity::Generate("client")).Pass());
     }
-    server_identity_ = rtc::SSLIdentity::Generate("server");
+    server_certificate_ = webrtc::DtlsCertificate::Create(
+        rtc::scoped_ptr<rtc::SSLIdentity>(
+            rtc::SSLIdentity::Generate("server")).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_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_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 568 matching lines @@
   std::string client_cipher;
   ASSERT_TRUE(GetSslCipher(true, &client_cipher));
   std::string server_cipher;
   ASSERT_TRUE(GetSslCipher(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
   ASSERT_EQ(
       rtc::SSLStreamAdapter::GetDefaultSslCipher(rtc::SSL_PROTOCOL_DTLS_10),
       client_cipher);
 }