Created the DtlsSrtpTransport.

pc/channel.h

 /*
  *  Copyright 2004 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 12 matching lines @@
 #include "media/base/mediachannel.h"
 #include "media/base/mediaengine.h"
 #include "media/base/streamparams.h"
 #include "media/base/videosinkinterface.h"
 #include "media/base/videosourceinterface.h"
 #include "p2p/base/dtlstransportinternal.h"
 #include "p2p/base/packettransportinternal.h"
 #include "p2p/base/transportcontroller.h"
 #include "p2p/client/socketmonitor.h"
 #include "pc/audiomonitor.h"
+#include "pc/dtlssrtptransport.h"
 #include "pc/mediamonitor.h"
 #include "pc/mediasession.h"
 #include "pc/rtcpmuxfilter.h"
+#include "pc/rtptransport.h"
 #include "pc/srtpfilter.h"
+#include "pc/srtptransport.h"
 #include "rtc_base/asyncinvoker.h"
 #include "rtc_base/asyncudpsocket.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/network.h"
 #include "rtc_base/sigslot.h"
 #include "rtc_base/window.h"
 
 namespace webrtc {
 class AudioSinkInterface;
 class RtpTransportInternal;
-class SrtpTransport;
 }  // namespace webrtc
 
 namespace cricket {
 
 struct CryptoParams;
 class MediaContentDescription;
 
 // BaseChannel contains logic common to voice and video, including enable,
 // marshaling calls to a worker and network threads, and connection and media
 // monitors.
@@ skipping 38 matching lines @@
   rtc::Thread* worker_thread() const { return worker_thread_; }
   rtc::Thread* network_thread() const { return network_thread_; }
   const std::string& content_name() const { return content_name_; }
   // TODO(deadbeef): This is redundant; remove this.
   const std::string& transport_name() const { return transport_name_; }
   bool enabled() const { return enabled_; }
 
   // This function returns true if we are using SDES.
   bool sdes_active() const { return sdes_negotiator_.IsActive(); }
   // The following function returns true if we are using DTLS-based keying.
-  bool dtls_active() const { return dtls_active_; }
+  bool dtls_active() const {
+    return dtls_srtp_transport_ && dtls_srtp_transport_->IsActive();
+  }
   // This function returns true if using SRTP (DTLS-based keying or SDES).
   bool srtp_active() const { return sdes_active() || dtls_active(); }
 
   bool writable() const { return writable_; }
 
   // Set the transport(s), and update writability and "ready-to-send" state.
   // |rtp_transport| must be non-null.
   // |rtcp_transport| must be supplied if NeedsRtcpTransport() is true (meaning
   // RTCP muxing is not fully active yet).
   // |rtp_transport| and |rtcp_transport| must share the same transport name as
@@ skipping 211 matching lines @@
       const std::vector<webrtc::RtpExtension>& extensions);
 
   bool CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos,
                          bool* dtls,
                          std::string* error_desc);
   bool SetSrtp_n(const std::vector<CryptoParams>& params,
                  ContentAction action,
                  ContentSource src,
                  const std::vector<int>& encrypted_extension_ids,
                  std::string* error_desc);
+  bool SetSdesSrtp_n(const std::vector<CryptoParams>& params,
+                     ContentAction action,
+                     ContentSource src,
+                     const std::vector<int>& encrypted_extension_ids);
+  bool SetDtlsSrtp_n(ContentSource src,
+                     const std::vector<int>& encrypted_extension_ids);
+
   bool SetRtcpMux_n(bool enable,
                     ContentAction action,
                     ContentSource src,
                     std::string* error_desc);
 
   // From MessageHandler
   void OnMessage(rtc::Message* pmsg) override;
 
   // Handled in derived classes
   virtual void OnConnectionMonitorUpdate(ConnectionMonitor* monitor,
@@ skipping 14 matching lines @@
                      rtc::PacketTransportInternal* rtcp_packet_transport);
   void DisconnectTransportChannels_n();
   void SignalSentPacket_n(rtc::PacketTransportInternal* transport,
                           const rtc::SentPacket& sent_packet);
   void SignalSentPacket_w(const rtc::SentPacket& sent_packet);
   bool IsReadyToSendMedia_n() const;
   void CacheRtpAbsSendTimeHeaderExtension_n(int rtp_abs_sendtime_extn_id);
   int GetTransportOverheadPerPacket() const;
   void UpdateTransportOverhead();
   // Wraps the existing RtpTransport in an SrtpTransport.
-  void EnableSrtpTransport_n();
+  void EnableSdes_n();
+  // Create an SrtpTransport and wrap it in an DtlsSrptTransport.

[Taylor Brandstetter, 2017/09/27 23:54:48]

DtlsSrtpTransport

+  void EnableDtlsSrtp_n();
+  // Cache the send/recv encrypted header extension ids before the
+  // DtlsSrtpTransport is enabled.
+  void CacheEncryptedHeaderExtensionIds(cricket::ContentSource source,
+                                        const std::vector<int>& extension_ids);
 
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   rtc::Thread* const signaling_thread_;
   rtc::AsyncInvoker invoker_;
 
   const std::string content_name_;
   std::unique_ptr<ConnectionMonitor> connection_monitor_;
 
   // Won't be set when using raw packet transports. SDP-specific thing.
   std::string transport_name_;
 
   const bool rtcp_mux_required_;
 
+  std::vector<int> send_encrypted_header_extension_ids_;
+  std::vector<int> recv_encrypted_header_extension_ids_;
+
   // Separate DTLS/non-DTLS pointers to support using BaseChannel without DTLS.
   // Temporary measure until more refactoring is done.
   // If non-null, "X_dtls_transport_" will always equal "X_packet_transport_".
   DtlsTransportInternal* rtp_dtls_transport_ = nullptr;
   DtlsTransportInternal* rtcp_dtls_transport_ = nullptr;
   std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport_;
-  webrtc::SrtpTransport* srtp_transport_ = nullptr;
+  webrtc::SrtpTransport* sdes_transport_ = nullptr;
+  webrtc::DtlsSrtpTransport* dtls_srtp_transport_ = nullptr;
+
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter sdes_negotiator_;
   RtcpMuxFilter rtcp_mux_filter_;
   bool writable_ = false;
   bool was_ever_writable_ = false;
   bool has_received_packet_ = false;
-  bool dtls_active_ = false;
   const bool srtp_required_ = true;
 
   // MediaChannel related members that should be accessed from the worker
   // thread.
   MediaChannel* const media_channel_;
   // Currently the |enabled_| flag is accessed from the signaling thread as
   // well, but it can be changed only when signaling thread does a synchronous
   // call to the worker thread, so it should be safe.
   bool enabled_ = false;
   std::vector<StreamParams> local_streams_;
@@ skipping 305 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // PC_CHANNEL_H_