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 147 matching lines @@
     if (offer_mdesc->type() != answer_mdesc->type()) {
       return false;
     }
   }
   return true;
 }
 
 // Checks that each non-rejected content has SDES crypto keys or a DTLS
 // fingerprint. Mismatches, such as replying with a DTLS fingerprint to SDES
 // keys, will be caught in Transport negotiation, and backstopped by Channel's
-// |secure_required| check.
+// |srtp_required| check.
 static bool VerifyCrypto(const SessionDescription* desc,
                          bool dtls_enabled,
                          std::string* error) {
   const ContentInfos& contents = desc->contents();
   for (size_t index = 0; index < contents.size(); ++index) {
     const ContentInfo* cinfo = &contents[index];
     if (cinfo->rejected) {
       continue;
     }
 
@@ skipping 45 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::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;
@@ skipping 32 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, SrtpRequired(),
+      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, SrtpRequired(),
+      video_options_));
   if (!video_channel_) {
     return false;
   }
   if (require_rtcp_mux) {
     video_channel_->ActivateRtcpMux();
   }
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVideoChannelCreated();
@@ skipping 11 matching lines @@
         bundle_transport ? *bundle_transport : content->name;
     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(), media_controller_, content->name,
-      bundle_transport, create_rtcp_transport_channel, data_channel_type_));
+      media_controller_, transport_controller_.get(), content->name,
+      bundle_transport, create_rtcp_transport_channel, SrtpRequired(),
+      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 187 matching lines @@
   cricket::ContentInfo content =
       current_remote_desc->description()->contents()[mediacontent_index];
 
   const std::string transport_name = GetTransportName(content.name);
   if (transport_name.empty()) {
     return false;
   }
   return transport_controller_->ReadyForRemoteCandidates(transport_name);
 }
 
+bool WebRtcSession::SrtpRequired() const {
+  return dtls_enabled_ ||
+         webrtc_session_desc_factory_->SdesPolicy() == cricket::SEC_REQUIRED;
+}
+
 void WebRtcSession::OnTransportControllerGatheringState(
     cricket::IceGatheringState state) {
   ASSERT(signaling_thread()->IsCurrent());
   if (state == cricket::kIceGatheringGathering) {
     if (ice_observer_) {
       ice_observer_->OnIceGatheringChange(
           PeerConnectionInterface::kIceGatheringGathering);
     }
   } else if (state == cricket::kIceGatheringComplete) {
     if (ice_observer_) {
@@ skipping 138 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