Support encrypted RTP extensions (RFC 6904)

webrtc/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 285 matching lines @@
   void ChannelNotWritable_n();
 
   bool AddRecvStream_w(const StreamParams& sp);
   bool RemoveRecvStream_w(uint32_t ssrc);
   bool AddSendStream_w(const StreamParams& sp);
   bool RemoveSendStream_w(uint32_t ssrc);
   bool ShouldSetupDtlsSrtp_n() const;
   // Do the DTLS key expansion and impose it on the SRTP/SRTCP filters.
   // |rtcp_channel| indicates whether to set up the RTP or RTCP filter.
   bool SetupDtlsSrtp_n(bool rtcp);
-  void MaybeSetupDtlsSrtp_n();
+  // Returns true if DTLS-SRTP has been setup.
+  bool MaybeSetupDtlsSrtp_n();
   // Set the DTLS-SRTP cipher policy on this channel as appropriate.
   bool SetDtlsSrtpCryptoSuites_n(DtlsTransportInternal* transport, bool rtcp);
 
   // Should be called whenever the conditions for
   // IsReadyToReceiveMedia/IsReadyToSendMedia are satisfied (or unsatisfied).
   // Updates the send/recv state of the media channel.
   void UpdateMediaSendRecvState();
   virtual void UpdateMediaSendRecvState_w() = 0;
 
   // Gets the content info appropriate to the channel (audio or video).
@@ skipping 17 matching lines @@
                                  std::string* error_desc);
   bool SetRtpTransportParameters_n(const MediaContentDescription* content,
                                    ContentAction action,
                                    ContentSource src,
                                    std::string* error_desc);
 
   // Helper method to get RTP Absoulute SendTime extension header id if
   // present in remote supported extensions list.
   void MaybeCacheRtpAbsSendTimeHeaderExtension_w(
       const std::vector<webrtc::RtpExtension>& extensions);
+  void PrepareHeaderExtensions_w(ContentSource source,
+      const std::vector<webrtc::RtpExtension>& extensions);

[pthatcher1, 2017/03/21 07:07:06]

void PrepareRtpHeaderExtensions_w would be a better name.

Also, prepare them for what?  This could use a comment.

[joachim, 2017/03/23 00:04:33]

Method has been removed.

 
   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,
                  std::string* error_desc);
   bool SetRtcpMux_n(bool enable,
                     ContentAction action,
@@ skipping 24 matching lines @@
   bool InitNetwork_n(DtlsTransportInternal* rtp_dtls_transport,
                      DtlsTransportInternal* rtcp_dtls_transport,
                      rtc::PacketTransportInternal* rtp_packet_transport,
                      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);
+  void PrepareHeaderExtensions_n(ContentSource source,
+      const std::vector<webrtc::RtpExtension> encrypted_headers);
   int GetTransportOverheadPerPacket() const;
   void UpdateTransportOverhead();
 
   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_;
@@ skipping 18 matching lines @@
   BundleFilter bundle_filter_;
   bool rtp_ready_to_send_ = false;
   bool rtcp_ready_to_send_ = false;
   bool writable_ = false;
   bool was_ever_writable_ = false;
   bool has_received_packet_ = false;
   bool dtls_keyed_ = false;
   const bool srtp_required_ = true;
   rtc::CryptoOptions crypto_options_;
   int rtp_abs_sendtime_extn_id_ = -1;
+  std::vector<webrtc::RtpExtension> rtp_local_encrypted_headers_;
+  std::vector<webrtc::RtpExtension> rtp_remote_encrypted_headers_;
+
+  static const int kNoEncryptedHeadersReady = 0;
+  static const int kLocalEncryptedHeadersReady = 1;
+  static const int kRemoteEncryptedHeadersReady = 2;
+  static const int kAllEncryptedHeadersReady =
+      kLocalEncryptedHeadersReady | kRemoteEncryptedHeadersReady;
+  int rtp_encrypted_headers_ready_ = kNoEncryptedHeadersReady;

[Taylor Brandstetter, 2017/03/22 18:00:11]

Can this extra state be derived from existing information? In which case it
could just be replaced by a helper method?

[joachim, 2017/03/23 00:04:33]

I completely removed the extra state.

 
   // 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_;
   std::vector<StreamParams> remote_streams_;
@@ skipping 309 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_PC_CHANNEL_H_