Replacing SSLIdentity* with scoped_refptr<RTCCertificate> in TransportChannel layer

webrtc/p2p/base/dtlstransportchannel.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 77 matching lines @@
 
 DtlsTransportChannelWrapper::DtlsTransportChannelWrapper(
                                            Transport* transport,
                                            TransportChannelImpl* channel)
     : TransportChannelImpl(channel->content_name(), channel->component()),
       transport_(transport),
       worker_thread_(rtc::Thread::Current()),
       channel_(channel),
       downward_(NULL),
       dtls_state_(STATE_NONE),
-      local_identity_(NULL),
+      local_certificate_(nullptr),

[tommi, 2015/09/03 20:06:04]

this is a scoped_refptr now, so no need for including in initializer list

[hbos, 2015/09/07 08:11:01]

Done.

       ssl_role_(rtc::SSL_CLIENT),
       ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_10) {
   channel_->SignalReadableState.connect(this,
       &DtlsTransportChannelWrapper::OnReadableState);
   channel_->SignalWritableState.connect(this,
       &DtlsTransportChannelWrapper::OnWritableState);
   channel_->SignalReadPacket.connect(this,
       &DtlsTransportChannelWrapper::OnReadPacket);
   channel_->SignalReadyToSend.connect(this,
       &DtlsTransportChannelWrapper::OnReadyToSend);
@@ skipping 17 matching lines @@
 }
 
 void DtlsTransportChannelWrapper::Connect() {
   // We should only get a single call to Connect.
   ASSERT(dtls_state_ == STATE_NONE ||
          dtls_state_ == STATE_OFFERED ||
          dtls_state_ == STATE_ACCEPTED);
   channel_->Connect();
 }
 
-bool DtlsTransportChannelWrapper::SetLocalIdentity(
-    rtc::SSLIdentity* identity) {
+bool DtlsTransportChannelWrapper::SetLocalCertificate(
+    const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
   if (dtls_state_ != STATE_NONE) {
-    if (identity == local_identity_) {
+    if (certificate == local_certificate_) {
       // This may happen during renegotiation.
       LOG_J(LS_INFO, this) << "Ignoring identical DTLS identity";
       return true;
     } else {
       LOG_J(LS_ERROR, this) << "Can't change DTLS local identity in this state";
       return false;
     }
   }
 
-  if (identity) {
-    local_identity_ = identity;
+  if (certificate) {
+    local_certificate_ = certificate;
     dtls_state_ = STATE_OFFERED;
   } else {
     LOG_J(LS_INFO, this) << "NULL DTLS identity supplied. Not doing DTLS";
   }
 
   return true;
 }
 
-bool DtlsTransportChannelWrapper::GetLocalIdentity(
-    rtc::SSLIdentity** identity) const {
-  if (!local_identity_)
+bool DtlsTransportChannelWrapper::GetLocalCertificate(
+    rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const {
+  if (!local_certificate_)
     return false;
 
-  *identity = local_identity_->GetReference();
+  *certificate = local_certificate_;
   return true;
 }
 
 bool DtlsTransportChannelWrapper::SetSslMaxProtocolVersion(
     rtc::SSLProtocolVersion version) {
   if (dtls_state_ != STATE_NONE) {
     LOG(LS_ERROR) << "Not changing max. protocol version "
                   << "while DTLS is negotiating";
     return false;
   }
@@ skipping 63 matching lines @@
 
   if (!SetupDtls()) {
     dtls_state_ = STATE_CLOSED;
     return false;
   }
 
   dtls_state_ = STATE_ACCEPTED;
   return true;
 }
 
-bool DtlsTransportChannelWrapper::GetRemoteCertificate(
+bool DtlsTransportChannelWrapper::GetRemoteSSLCertificate(
     rtc::SSLCertificate** cert) const {
   if (!dtls_)
     return false;
 
   return dtls_->GetPeerCertificate(cert);
 }
 
 bool DtlsTransportChannelWrapper::SetupDtls() {
   StreamInterfaceChannel* downward = new StreamInterfaceChannel(channel_);
 
   dtls_.reset(rtc::SSLStreamAdapter::Create(downward));
   if (!dtls_) {
     LOG_J(LS_ERROR, this) << "Failed to create DTLS adapter.";
     delete downward;
     return false;
   }
 
   downward_ = downward;
 
-  dtls_->SetIdentity(local_identity_->GetReference());
+  dtls_->SetIdentity(local_certificate_->identity()->GetReference());
   dtls_->SetMode(rtc::SSL_MODE_DTLS);
   dtls_->SetMaxProtocolVersion(ssl_max_version_);
   dtls_->SetServerRole(ssl_role_);
   dtls_->SignalEvent.connect(this, &DtlsTransportChannelWrapper::OnDtlsEvent);
   if (!dtls_->SetPeerCertificateDigest(
           remote_fingerprint_algorithm_,
           reinterpret_cast<unsigned char*>(remote_fingerprint_value_.data()),
           remote_fingerprint_value_.size())) {
     LOG_J(LS_ERROR, this) << "Couldn't set DTLS certificate digest.";
     return false;
@@ skipping 366 matching lines @@
   SignalRouteChange(this, candidate);
 }
 
 void DtlsTransportChannelWrapper::OnConnectionRemoved(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
   SignalConnectionRemoved(this);
 }
 
 }  // namespace cricket