Added DtlsCertificate, a ref counted object owning an SSLIdentity

talk/session/media/channel_unittest.cc

 /*
  * libjingle
  * Copyright 2009 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 103 matching lines @@
 };
 
 
 rtc::StreamInterface* Open(const std::string& path) {
   return rtc::Filesystem::OpenFile(
       rtc::Pathname(path), "wb");
 }
 
 // Base class for Voice/VideoChannel tests
 template<class T>
 class ChannelTest : public testing::Test, public sigslot::has_slots<> {

[Henrik Grunell WebRTC, 2015/08/12 14:46:30]

Should we add new tests?

[hbos, 2015/08/14 14:09:39]

In this case the swap does not change or extend functionality. The identity ->
certificate change should not change what the tests need to cover.

  public:
   enum Flags { RTCP = 0x1, RTCP_MUX = 0x2, SECURE = 0x4, SSRC_MUX = 0x8,
                DTLS = 0x10 };
 
   ChannelTest(const uint8* rtp_data, int rtp_len,
               const uint8* rtcp_data, int rtcp_len)
       : session1_(true),
         session2_(false),
         media_channel1_(NULL),
         media_channel2_(NULL),
@@ skipping 53 matching lines @@
       flags2 = (flags2 & ~SECURE);
     }
     CreateContent(flags1, kPcmuCodec, kH264Codec,
                   &local_media_content1_);
     CreateContent(flags2, kPcmuCodec, kH264Codec,
                   &local_media_content2_);
     CopyContent(local_media_content1_, &remote_media_content1_);
     CopyContent(local_media_content2_, &remote_media_content2_);
 
     if (flags1 & DTLS) {
-      identity1_.reset(rtc::SSLIdentity::Generate("session1"));
-      session1_.set_ssl_identity(identity1_.get());
+      rtc::scoped_refptr<webrtc::DtlsCertificate> certificate =
+          webrtc::DtlsCertificate::Create(
+              rtc::scoped_ptr<rtc::SSLIdentity>(
+                  rtc::SSLIdentity::Generate("session1")).Pass());
+      session1_.set_ssl_certificate(certificate);
     }
     if (flags2 & DTLS) {
-      identity2_.reset(rtc::SSLIdentity::Generate("session2"));
-      session2_.set_ssl_identity(identity2_.get());
+      rtc::scoped_refptr<webrtc::DtlsCertificate> certificate =
+          webrtc::DtlsCertificate::Create(
+              rtc::scoped_ptr<rtc::SSLIdentity>(
+                  rtc::SSLIdentity::Generate("session2")).Pass());
+      session2_.set_ssl_certificate(certificate);
     }
 
     // Add stream information (SSRC) to the local content but not to the remote
     // content. This means that we per default know the SSRC of what we send but
     // not what we receive.
     AddLegacyStreamInContent(kSsrc1, flags1, &local_media_content1_);
     AddLegacyStreamInContent(kSsrc2, flags2, &local_media_content2_);
 
     // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
     if (flags1 & SSRC_MUX) {
@@ skipping 1568 matching lines @@
   cricket::FakeMediaEngine media_engine_;
   // The media channels are owned by the voice channel objects below.
   typename T::MediaChannel* media_channel1_;
   typename T::MediaChannel* media_channel2_;
   rtc::scoped_ptr<typename T::Channel> channel1_;
   rtc::scoped_ptr<typename T::Channel> channel2_;
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
-  rtc::scoped_ptr<rtc::SSLIdentity> identity1_;
-  rtc::scoped_ptr<rtc::SSLIdentity> identity2_;
   // The RTP and RTCP packets to send in the tests.
   std::string rtp_packet_;
   std::string rtcp_packet_;
   int media_info_callbacks1_;
   int media_info_callbacks2_;
   bool mute_callback_recved_;
   bool mute_callback_value_;
 
   uint32 ssrc_;
   typename T::MediaChannel::Error error_;
@@ skipping 1070 matching lines @@
   };
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?