Removing "crypto_required" from MediaContentDescription.

webrtc/api/webrtcsession.cc

 /*
  *  Copyright 2012 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 213 matching lines @@
     }
     if (tinfo->description.ice_ufrag.empty() ||
         tinfo->description.ice_pwd.empty()) {
       LOG(LS_ERROR) << "Session description must have ice ufrag and pwd.";
       return false;
     }
   }
   return true;
 }
 
-// Forces |sdesc->crypto_required| to the appropriate state based on the
-// current security policy, to ensure a failure occurs if there is an error
-// in crypto negotiation.
-// Called when processing the local session description.
-static void UpdateSessionDescriptionSecurePolicy(cricket::CryptoType type,
-                                                 SessionDescription* sdesc) {
-  if (!sdesc) {
-    return;
-  }
-
-  // Updating the |crypto_required_| in MediaContentDescription to the
-  // appropriate state based on the current security policy.
-  for (cricket::ContentInfos::iterator iter = sdesc->contents().begin();
-       iter != sdesc->contents().end(); ++iter) {
-    if (cricket::IsMediaContent(&*iter)) {
-      MediaContentDescription* mdesc =
-          static_cast<MediaContentDescription*> (iter->description);
-      if (mdesc) {
-        mdesc->set_crypto_required(type);
-      }
-    }
-  }
-}
-
 static bool GetAudioSsrcByTrackId(const SessionDescription* session_description,
                                   const std::string& track_id,
                                   uint32_t* ssrc) {
   const cricket::ContentInfo* audio_info =
       cricket::GetFirstAudioContent(session_description);
   if (!audio_info) {
     LOG(LS_ERROR) << "Audio not used in this call";
     return false;
   }
 
@@ skipping 366 matching lines @@
   }
   if (video_channel() && video_channel()->content_name() == content_name) {
     return video_channel();
   }
   if (data_channel() && data_channel()->content_name() == content_name) {
     return data_channel();
   }
   return nullptr;
 }
 
-void WebRtcSession::SetSdesPolicy(cricket::SecurePolicy secure_policy) {
-  webrtc_session_desc_factory_->SetSdesPolicy(secure_policy);
-}
-
 cricket::SecurePolicy WebRtcSession::SdesPolicy() const {
   return webrtc_session_desc_factory_->SdesPolicy();
 }
 
+bool WebRtcSession::SecureRequired() const {
+  return dtls_enabled_ ||
+         webrtc_session_desc_factory_->SdesPolicy() == cricket::SEC_REQUIRED;
+}
+
 bool WebRtcSession::GetSslRole(const std::string& transport_name,
                                rtc::SSLRole* role) {
   if (!local_desc_ || !remote_desc_) {
     LOG(LS_INFO) << "Local and Remote descriptions must be applied to get "
                  << "SSL Role of the session.";
     return false;
   }
 
   return transport_controller_->GetSslRole(transport_name, role);
 }
@@ skipping 28 matching lines @@
     return false;
   }
 
   // Update the initial_offerer flag if this session is the initial_offerer.
   Action action = GetAction(desc->type());
   if (state() == STATE_INIT && action == kOffer) {
     initial_offerer_ = true;
     transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLING);
   }
 
-  cricket::SecurePolicy sdes_policy =
-      webrtc_session_desc_factory_->SdesPolicy();
-  cricket::CryptoType crypto_required = dtls_enabled_ ?
-      cricket::CT_DTLS : (sdes_policy == cricket::SEC_REQUIRED ?
-          cricket::CT_SDES : cricket::CT_NONE);
-  // Update the MediaContentDescription crypto settings as per the policy set.
-  UpdateSessionDescriptionSecurePolicy(crypto_required, desc->description());
-
   local_desc_.reset(desc_temp.release());
 
   // Transport and Media channels will be created only when offer is set.
   if (action == kOffer && !CreateChannels(local_desc_->description())) {
     // TODO(mallinath) - Handle CreateChannel failure, as new local description
     // is applied. Restore back to old description.
     return BadLocalSdp(desc->type(), kCreateChannelFailed, err_desc);
   }
 
   // Remove unused channels if MediaContentDescription is rejected.
@@ skipping 938 matching lines @@
   return true;
 }
 
 bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content,
                                        const std::string* bundle_transport) {
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
   bool create_rtcp_transport_channel = !require_rtcp_mux;
   voice_channel_.reset(channel_manager_->CreateVoiceChannel(
       media_controller_, transport_controller_.get(), content->name,
-      bundle_transport, create_rtcp_transport_channel, audio_options_));
+      bundle_transport, create_rtcp_transport_channel, SecureRequired(),

[pthatcher1, 2016/11/30 19:16:17]

Does SecureRequired()/srtp_required() need to be public?  It seems like it could
be private.

[Taylor Brandstetter, 2016/12/01 02:41:34]

I guess so. I just made it public because SdesPolicy already is, and it's even
more granular.

+      audio_options_));
   if (!voice_channel_) {
     return false;
   }
   if (require_rtcp_mux) {
     voice_channel_->ActivateRtcpMux();
   }
 
   voice_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVoiceChannelCreated();
   voice_channel_->SignalSentPacket.connect(this,
                                            &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content,
                                        const std::string* bundle_transport) {
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
   bool create_rtcp_transport_channel = !require_rtcp_mux;
   video_channel_.reset(channel_manager_->CreateVideoChannel(
       media_controller_, transport_controller_.get(), content->name,
-      bundle_transport, create_rtcp_transport_channel, video_options_));
+      bundle_transport, create_rtcp_transport_channel, SecureRequired(),
+      video_options_));
   if (!video_channel_) {
     return false;
   }
   if (require_rtcp_mux) {
     video_channel_->ActivateRtcpMux();
   }
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVideoChannelCreated();
@@ skipping 12 matching lines @@
     quic_data_transport_->SetTransport(transport_name);
     return true;
   }
 #endif  // HAVE_QUIC
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
   bool create_rtcp_transport_channel = !sctp && !require_rtcp_mux;
   data_channel_.reset(channel_manager_->CreateDataChannel(
       transport_controller_.get(), content->name, bundle_transport,
-      create_rtcp_transport_channel, data_channel_type_));
+      create_rtcp_transport_channel, SecureRequired(), data_channel_type_));
   if (!data_channel_) {
     return false;
   }
   if (require_rtcp_mux) {
     data_channel_->ActivateRtcpMux();
   }
 
   if (sctp) {
     data_channel_->SignalDataReceived.connect(
         this, &WebRtcSession::OnDataChannelMessageReceived);
@@ skipping 345 matching lines @@
 }
 
 void WebRtcSession::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
   if (metrics_observer_) {
     metrics_observer_->IncrementEnumCounter(
         webrtc::kEnumCounterDtlsHandshakeError, static_cast<int>(error),
         static_cast<int>(rtc::SSLHandshakeError::MAX_VALUE));
   }
 }
 }  // namespace webrtc