Removing "crypto_required" from MediaContentDescription.

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 58 matching lines @@
 // This is required to avoid a data race between the destructor modifying the
 // vtable, and the media channel's thread using BaseChannel as the
 // NetworkInterface.
 
 class BaseChannel
     : public rtc::MessageHandler, public sigslot::has_slots<>,
       public MediaChannel::NetworkInterface,
       public ConnectionStatsGetter {
  public:
   // |rtcp| represents whether or not this channel uses RTCP.
+  // If |srtp_required| is true, the channel will not send or receive any
+  // RTP/RTCP packets without using SRTP (either using SDES or DTLS-SRTP).
   BaseChannel(rtc::Thread* worker_thread,
               rtc::Thread* network_thread,
               MediaChannel* channel,
               TransportController* transport_controller,
               const std::string& content_name,
-              bool rtcp);
+              bool rtcp,
+              bool srtp_required);
   virtual ~BaseChannel();
   bool Init_w(const std::string* bundle_transport_name);
   // Deinit may be called multiple times and is simply ignored if it's already
   // done.
   void Deinit();
 
   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_; }
   const std::string& transport_name() const { return transport_name_; }
   bool enabled() const { return enabled_; }
 
   // This function returns true if we are using SRTP.
   bool secure() const { return srtp_filter_.IsActive(); }
   // The following function returns true if we are using
   // DTLS-based keying. If you turned off SRTP later, however
   // you could have secure() == false and dtls_secure() == true.
   bool secure_dtls() const { return dtls_keyed_; }
-  // This function returns true if we require secure channel for call setup.
-  bool secure_required() const { return secure_required_; }
+  // This function returns true if we require SRTP for call setup.
+  bool srtp_required() const { return srtp_required_; }

[pthatcher1, 2016/12/01 22:57:12]

Could you leave a comment that this is only public for testing?

[Taylor Brandstetter, 2016/12/02 00:42:32]

Done.

 
   bool writable() const { return writable_; }
 
   // Activate RTCP mux, regardless of the state so far.  Once
   // activated, it can not be deactivated, and if the remote
   // description doesn't support RTCP mux, setting the remote
   // description will fail.
   void ActivateRtcpMux();
   bool SetTransport(const std::string& transport_name);
   bool PushdownLocalDescription(const SessionDescription* local_desc,
@@ skipping 84 matching lines @@
   // disconnects from the old channel and connects to the new one.
   void SetTransportChannel_n(bool rtcp, TransportChannel* new_channel);
 
   bool was_ever_writable() const { return was_ever_writable_; }
   void set_local_content_direction(MediaContentDirection direction) {
     local_content_direction_ = direction;
   }
   void set_remote_content_direction(MediaContentDirection direction) {
     remote_content_direction_ = direction;
   }
-  void set_secure_required(bool secure_required) {
-    secure_required_ = secure_required;
-  }
   // These methods verify that:
   // * The required content description directions have been set.
   // * The channel is enabled.
   // * And for sending:
   //   - The SRTP filter is active if it's needed.
   //   - The transport has been writable before, meaning it should be at least
   //     possible to succeed in sending a packet.
   //
   // When any of these properties change, UpdateMediaSendRecvState_w should be
   // called.
@@ skipping 168 matching lines @@
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   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;
-  bool secure_required_ = false;
+  const bool srtp_required_ = true;
   rtc::CryptoOptions crypto_options_;
   int rtp_abs_sendtime_extn_id_ = -1;
 
   // 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_;
   MediaContentDirection local_content_direction_ = MD_INACTIVE;
   MediaContentDirection remote_content_direction_ = MD_INACTIVE;
   CandidatePairInterface* selected_candidate_pair_;
 };
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* worker_thread,
                rtc::Thread* network_thread,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
                TransportController* transport_controller,
                const std::string& content_name,
-               bool rtcp);
+               bool rtcp,
+               bool srtp_required);
   ~VoiceChannel();
   bool Init_w(const std::string* bundle_transport_name);
 
   // Configure sending media on the stream with SSRC |ssrc|
   // If there is only one sending stream SSRC 0 can be used.
   bool SetAudioSend(uint32_t ssrc,
                     bool enable,
                     const AudioOptions* options,
                     AudioSource* source);
 
@@ skipping 96 matching lines @@
 };
 
 // VideoChannel is a specialization for video.
 class VideoChannel : public BaseChannel {
  public:
   VideoChannel(rtc::Thread* worker_thread,
                rtc::Thread* netwokr_thread,
                VideoMediaChannel* channel,
                TransportController* transport_controller,
                const std::string& content_name,
-               bool rtcp);
+               bool rtcp,
+               bool srtp_required);
   ~VideoChannel();
   bool Init_w(const std::string* bundle_transport_name);
 
   // downcasts a MediaChannel
   VideoMediaChannel* media_channel() const override {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
 
   bool SetSink(uint32_t ssrc,
                rtc::VideoSinkInterface<webrtc::VideoFrame>* sink);
@@ skipping 57 matching lines @@
 };
 
 // DataChannel is a specialization for data.
 class DataChannel : public BaseChannel {
  public:
   DataChannel(rtc::Thread* worker_thread,
               rtc::Thread* network_thread,
               DataMediaChannel* media_channel,
               TransportController* transport_controller,
               const std::string& content_name,
-              bool rtcp);
+              bool rtcp,
+              bool srtp_required);
   ~DataChannel();
   bool Init_w(const std::string* bundle_transport_name);
 
   virtual bool SendData(const SendDataParams& params,
                         const rtc::CopyOnWriteBuffer& payload,
                         SendDataResult* result);
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
 
@@ skipping 97 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_