Added DtlsCertificate, a ref counted object owning an SSLIdentity

webrtc/p2p/base/transportdescriptionfactory_unittest.cc

 /*
  *  Copyright 2012 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.
  */
 
 #include <string>
 #include <vector>
 
 #include "webrtc/p2p/base/constants.h"
 #include "webrtc/p2p/base/transportdescription.h"
 #include "webrtc/p2p/base/transportdescriptionfactory.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/ssladapter.h"
 
 using rtc::scoped_ptr;
 using cricket::TransportDescriptionFactory;
 using cricket::TransportDescription;
 using cricket::TransportOptions;
 
 class TransportDescriptionFactoryTest : public testing::Test {
  public:
   TransportDescriptionFactoryTest()
-      : id1_(new rtc::FakeSSLIdentity("User1")),
-        id2_(new rtc::FakeSSLIdentity("User2")) {
+      : cert1_(webrtc::DtlsCertificate::Create(
+          rtc::scoped_ptr<rtc::SSLIdentity>(
+              new rtc::FakeSSLIdentity("User1")).Pass())),
+        cert2_(webrtc::DtlsCertificate::Create(
+          rtc::scoped_ptr<rtc::SSLIdentity>(
+              new rtc::FakeSSLIdentity("User2")).Pass())) {
   }
 
   void CheckDesc(const TransportDescription* desc, const std::string& type,
                  const std::string& opt, const std::string& ice_ufrag,
                  const std::string& ice_pwd, const std::string& dtls_alg) {
     ASSERT_TRUE(desc != NULL);
     EXPECT_EQ(type, desc->transport_type);
     EXPECT_EQ(!opt.empty(), desc->HasOption(opt));
     if (ice_ufrag.empty() && ice_pwd.empty()) {
       EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
@@ skipping 14 matching lines @@
   }
 
   // This test ice restart by doing two offer answer exchanges. On the second
   // exchange ice is restarted. The test verifies that the ufrag and password
   // in the offer and answer is changed.
   // If |dtls| is true, the test verifies that the finger print is not changed.
   void TestIceRestart(bool dtls) {
     if (dtls) {
       f1_.set_secure(cricket::SEC_ENABLED);
       f2_.set_secure(cricket::SEC_ENABLED);
-      f1_.set_identity(id1_.get());
-      f2_.set_identity(id2_.get());
+      f1_.set_certificate(cert1_.get());
+      f2_.set_certificate(cert2_.get());
     } else {
       f1_.set_secure(cricket::SEC_DISABLED);
       f2_.set_secure(cricket::SEC_DISABLED);
     }
 
     cricket::TransportOptions options;
     // The initial offer / answer exchange.
     rtc::scoped_ptr<TransportDescription> offer(f1_.CreateOffer(
         options, NULL));
     rtc::scoped_ptr<TransportDescription> answer(
@@ skipping 30 matching lines @@
       EXPECT_FALSE(
           org_desc->identity_fingerprint->GetRfc4572Fingerprint().empty());
       EXPECT_EQ(org_desc->identity_fingerprint->GetRfc4572Fingerprint(),
                 restart_desc->identity_fingerprint->GetRfc4572Fingerprint());
     }
   }
 
  protected:
   TransportDescriptionFactory f1_;
   TransportDescriptionFactory f2_;
-  scoped_ptr<rtc::SSLIdentity> id1_;
-  scoped_ptr<rtc::SSLIdentity> id2_;
+  rtc::scoped_refptr<webrtc::DtlsCertificate> cert1_;
+  rtc::scoped_refptr<webrtc::DtlsCertificate> cert2_;
 };
 
 // Test that in the default case, we generate the expected G-ICE offer.
 TEST_F(TransportDescriptionFactoryTest, TestOfferGice) {
   f1_.set_protocol(cricket::ICEPROTO_GOOGLE);
   scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
       TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_GINGLE_P2P, "", "", "", "");
 }
 
@@ skipping 10 matching lines @@
   f1_.set_protocol(cricket::ICEPROTO_RFC5245);
   scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
       TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "", "", "", "");
 }
 
 // Test generating a hybrid offer with DTLS.
 TEST_F(TransportDescriptionFactoryTest, TestOfferHybridDtls) {
   f1_.set_protocol(cricket::ICEPROTO_HYBRID);
   f1_.set_secure(cricket::SEC_ENABLED);
-  f1_.set_identity(id1_.get());
+  f1_.set_certificate(cert1_.get());
   std::string digest_alg;
-  ASSERT_TRUE(id1_->certificate().GetSignatureDigestAlgorithm(&digest_alg));
+  ASSERT_TRUE(cert1_->identity()->certificate().GetSignatureDigestAlgorithm(
+      &digest_alg));
   scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
       TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "google-ice", "", "",
             digest_alg);
   // Ensure it also works with SEC_REQUIRED.
   f1_.set_secure(cricket::SEC_REQUIRED);
   desc.reset(f1_.CreateOffer(TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "google-ice", "", "",
             digest_alg);
 }
 
 // Test generating a hybrid offer with DTLS fails with no identity.
 TEST_F(TransportDescriptionFactoryTest, TestOfferHybridDtlsWithNoIdentity) {
   f1_.set_protocol(cricket::ICEPROTO_HYBRID);
   f1_.set_secure(cricket::SEC_ENABLED);
   scoped_ptr<TransportDescription> desc(f1_.CreateOffer(
       TransportOptions(), NULL));
   ASSERT_TRUE(desc.get() == NULL);
 }
 
 // Test updating a hybrid offer with DTLS to pick ICE.
 // The ICE credentials should stay the same in the new offer.
 TEST_F(TransportDescriptionFactoryTest, TestOfferHybridDtlsReofferIceDtls) {
   f1_.set_protocol(cricket::ICEPROTO_HYBRID);
   f1_.set_secure(cricket::SEC_ENABLED);
-  f1_.set_identity(id1_.get());
+  f1_.set_certificate(cert1_.get());
   std::string digest_alg;
-  ASSERT_TRUE(id1_->certificate().GetSignatureDigestAlgorithm(&digest_alg));
+  ASSERT_TRUE(cert1_->identity()->certificate().GetSignatureDigestAlgorithm(
+      &digest_alg));
   scoped_ptr<TransportDescription> old_desc(f1_.CreateOffer(
       TransportOptions(), NULL));
   ASSERT_TRUE(old_desc.get() != NULL);
   f1_.set_protocol(cricket::ICEPROTO_RFC5245);
   scoped_ptr<TransportDescription> desc(
       f1_.CreateOffer(TransportOptions(), old_desc.get()));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "",
             old_desc->ice_ufrag, old_desc->ice_pwd, digest_alg);
 }
 
@@ skipping 99 matching lines @@
                        old_desc.get()));
   ASSERT_TRUE(desc.get() != NULL);
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "",
             old_desc->ice_ufrag, old_desc->ice_pwd, "");
 }
 
 // Test that we handle answering an offer with DTLS with no DTLS.
 TEST_F(TransportDescriptionFactoryTest, TestAnswerHybridToHybridDtls) {
   f1_.set_protocol(cricket::ICEPROTO_HYBRID);
   f1_.set_secure(cricket::SEC_ENABLED);
-  f1_.set_identity(id1_.get());
+  f1_.set_certificate(cert1_.get());
   f2_.set_protocol(cricket::ICEPROTO_HYBRID);
   scoped_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   scoped_ptr<TransportDescription> desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "", "", "", "");
 }
 
 // Test that we handle answering an offer without DTLS if we have DTLS enabled,
 // but fail if we require DTLS.
 TEST_F(TransportDescriptionFactoryTest, TestAnswerHybridDtlsToHybrid) {
   f1_.set_protocol(cricket::ICEPROTO_HYBRID);
   f2_.set_protocol(cricket::ICEPROTO_HYBRID);
   f2_.set_secure(cricket::SEC_ENABLED);
-  f2_.set_identity(id2_.get());
+  f2_.set_certificate(cert2_.get());
   scoped_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   scoped_ptr<TransportDescription> desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "", "", "", "");
   f2_.set_secure(cricket::SEC_REQUIRED);
   desc.reset(f2_.CreateAnswer(offer.get(), TransportOptions(),
                               NULL));
   ASSERT_TRUE(desc.get() == NULL);
 }
 
 // Test that we handle answering an DTLS offer with DTLS, both if we have
 // DTLS enabled and required.
 TEST_F(TransportDescriptionFactoryTest, TestAnswerHybridDtlsToHybridDtls) {
   f1_.set_protocol(cricket::ICEPROTO_HYBRID);
   f1_.set_secure(cricket::SEC_ENABLED);
-  f1_.set_identity(id1_.get());
+  f1_.set_certificate(cert1_.get());
 
   f2_.set_protocol(cricket::ICEPROTO_HYBRID);
   f2_.set_secure(cricket::SEC_ENABLED);
-  f2_.set_identity(id2_.get());
+  f2_.set_certificate(cert2_.get());
   // f2_ produces the answer that is being checked in this test, so the
-  // answer must contain fingerprint lines with id2_'s digest algorithm.
+  // answer must contain fingerprint lines with cert2_'s digest algorithm.
   std::string digest_alg2;
-  ASSERT_TRUE(id2_->certificate().GetSignatureDigestAlgorithm(&digest_alg2));
+  ASSERT_TRUE(cert2_->identity()->certificate().GetSignatureDigestAlgorithm(
+      &digest_alg2));
 
   scoped_ptr<TransportDescription> offer(
       f1_.CreateOffer(TransportOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   scoped_ptr<TransportDescription> desc(
       f2_.CreateAnswer(offer.get(), TransportOptions(), NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "", "", "", digest_alg2);
   f2_.set_secure(cricket::SEC_REQUIRED);
   desc.reset(f2_.CreateAnswer(offer.get(), TransportOptions(),
                               NULL));
   CheckDesc(desc.get(), cricket::NS_JINGLE_ICE_UDP, "", "", "", digest_alg2);
 }
 
 // Test that ice ufrag and password is changed in an updated offer and answer
 // if |TransportDescriptionOptions::ice_restart| is true.
 TEST_F(TransportDescriptionFactoryTest, TestIceRestart) {
   TestIceRestart(false);
 }
 
 // Test that ice ufrag and password is changed in an updated offer and answer
 // if |TransportDescriptionOptions::ice_restart| is true and DTLS is enabled.
 TEST_F(TransportDescriptionFactoryTest, TestIceRestartWithDtls) {
   TestIceRestart(true);
 }