Support encrypted RTP extensions (RFC 6904)

webrtc/p2p/base/fakedtlstransport.h

 /*
  *  Copyright 2017 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 73 matching lines @@
     if (dest && !dest_) {
       // This simulates the DTLS handshake.
       dest_ = dest;
       if (local_cert_ && dest_->local_cert_) {
         do_dtls_ = true;
       }
       SetWritable(true);
       if (!asymmetric) {
         dest->SetDestination(this, true);
       }
+      dtls_state_ = DTLS_TRANSPORT_CONNECTED;
       ice_transport_->SetDestination(
           static_cast<FakeIceTransport*>(dest->ice_transport()), asymmetric);
     } else {
       // Simulates loss of connectivity, by asymmetrically forgetting dest_.
       dest_ = nullptr;
       SetWritable(false);
       ice_transport_->SetDestination(nullptr, asymmetric);
     }
   }
 
@@ skipping 11 matching lines @@
     return true;
   }
   bool SetSslRole(rtc::SSLRole role) override {
     ssl_role_ = role;
     return true;
   }
   bool GetSslRole(rtc::SSLRole* role) const override {
     *role = ssl_role_;
     return true;
   }
+  const rtc::CryptoOptions& crypto_options() const override {
+    return crypto_options_;
+  }
+  void SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
+    crypto_options_ = crypto_options;
+  }
   bool SetLocalCertificate(
       const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
     local_cert_ = certificate;
     return true;
   }
   void SetRemoteSSLCertificate(rtc::FakeSSLCertificate* cert) {
     remote_cert_ = cert;
   }
   bool IsDtlsActive() const override { return do_dtls_; }
   bool GetSrtpCryptoSuite(int* crypto_suite) override {
     if (!do_dtls_) {
       return false;
     }
-    *crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;
+    *crypto_suite = crypto_suite_;
     return true;
   }
+  void SetSrtpCryptoSuite(int crypto_suite) {
+    crypto_suite_ = crypto_suite;
+  }
   bool GetSslCipherSuite(int* cipher_suite) override { return false; }
   rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override {
     return local_cert_;
   }
   std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
       const override {
     return remote_cert_ ? std::unique_ptr<rtc::SSLCertificate>(
                               remote_cert_->GetReference())
                         : nullptr;
   }
@@ skipping 72 matching lines @@
   std::unique_ptr<FakeIceTransport> owned_ice_transport_;
   std::string transport_name_;
   int component_;
   FakeDtlsTransport* dest_ = nullptr;
   rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
   rtc::FakeSSLCertificate* remote_cert_ = nullptr;
   bool do_dtls_ = false;
   rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
   rtc::SSLFingerprint dtls_fingerprint_;
   rtc::SSLRole ssl_role_ = rtc::SSL_CLIENT;
+  int crypto_suite_ = rtc::SRTP_AES128_CM_SHA1_80;
+  rtc::CryptoOptions crypto_options_;
 
   DtlsTransportState dtls_state_ = DTLS_TRANSPORT_NEW;
 
   bool receiving_ = false;
   bool writable_ = false;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKEDTLSTRANSPORT_H_