Use new TransportController implementation in PeerConnection.
The TransportController will be replaced by the JsepTransportController
and JsepTransport will be replace be JsepTransport2.
The JsepTransportController will take the entire SessionDescription
and handle the RtcpMux, Sdes and BUNDLE internally.
The ownership model is also changed. The P2P layer transports are not
ref-counted and will be owned by the JsepTransport2.
In ORTC aspect, RtpTransportAdapter is now a wrapper over RtpTransport
or SrtpTransport and it implements the public and internal interface
by calling the transport underneath.
Bug: webrtc:8587
Change-Id: Ia7fa61288a566f211f8560072ea0eecaf19e48df
Reviewed-on: https://webrtc-review.googlesource.com/59586
Commit-Queue: Zhi Huang <zhihuang@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22693}diff --git a/pc/channel.cc b/pc/channel.cc
index 358cb77..6da6470 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -98,20 +98,16 @@
rtc::Thread* signaling_thread,
std::unique_ptr<MediaChannel> media_channel,
const std::string& content_name,
- bool rtcp_mux_required,
- bool srtp_required)
+ bool srtp_required,
+ rtc::CryptoOptions crypto_options)
: worker_thread_(worker_thread),
network_thread_(network_thread),
signaling_thread_(signaling_thread),
content_name_(content_name),
- rtcp_mux_required_(rtcp_mux_required),
- unencrypted_rtp_transport_(
- rtc::MakeUnique<webrtc::RtpTransport>(rtcp_mux_required)),
srtp_required_(srtp_required),
+ crypto_options_(crypto_options),
media_channel_(std::move(media_channel)) {
RTC_DCHECK_RUN_ON(worker_thread_);
- rtp_transport_ = unencrypted_rtp_transport_.get();
- ConnectToRtpTransport();
RTC_LOG(LS_INFO) << "Created channel for " << content_name;
}
@@ -162,33 +158,10 @@
rtp_transport_->SetMetricsObserver(nullptr);
}
-void BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
- DtlsTransportInternal* rtcp_dtls_transport,
- rtc::PacketTransportInternal* rtp_packet_transport,
- rtc::PacketTransportInternal* rtcp_packet_transport) {
- RTC_DCHECK_RUN_ON(worker_thread_);
- network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
- SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport,
- rtp_packet_transport, rtcp_packet_transport);
-
- if (rtcp_mux_required_) {
- rtcp_mux_filter_.SetActive();
- }
- });
-
- // Both RTP and RTCP channels should be set, we can call SetInterface on
- // the media channel and it can set network options.
- media_channel_->SetInterface(this);
-}
-
void BaseChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
RTC_DCHECK_RUN_ON(worker_thread_);
network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
SetRtpTransport(rtp_transport);
-
- if (rtcp_mux_required_) {
- rtcp_mux_filter_.SetActive();
- }
});
// Both RTP and RTCP channels should be set, we can call SetInterface on
@@ -205,11 +178,8 @@
network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
FlushRtcpMessages_n();
- if (dtls_srtp_transport_) {
- dtls_srtp_transport_->SetDtlsTransports(nullptr, nullptr);
- } else {
- rtp_transport_->SetRtpPacketTransport(nullptr);
- rtp_transport_->SetRtcpPacketTransport(nullptr);
+ if (rtp_transport_) {
+ DisconnectFromRtpTransport();
}
// Clear pending read packets/messages.
network_thread_->Clear(&invoker_);
@@ -221,143 +191,34 @@
if (!network_thread_->IsCurrent()) {
network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
SetRtpTransport(rtp_transport);
- return;
});
+ return;
}
- RTC_DCHECK(rtp_transport);
-
if (rtp_transport_) {
DisconnectFromRtpTransport();
}
+
rtp_transport_ = rtp_transport;
- RTC_LOG(LS_INFO) << "Setting the RtpTransport for " << content_name();
- ConnectToRtpTransport();
+ if (rtp_transport_) {
+ RTC_DCHECK(rtp_transport_->rtp_packet_transport());
+ transport_name_ = rtp_transport_->rtp_packet_transport()->transport_name();
- UpdateWritableState_n();
-}
+ ConnectToRtpTransport();
+ OnTransportReadyToSend(rtp_transport_->IsReadyToSend());
+ UpdateWritableState_n();
-void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport,
- DtlsTransportInternal* rtcp_dtls_transport) {
- network_thread_->Invoke<void>(
- RTC_FROM_HERE,
- Bind(&BaseChannel::SetTransports_n, this, rtp_dtls_transport,
- rtcp_dtls_transport, rtp_dtls_transport, rtcp_dtls_transport));
-}
-
-void BaseChannel::SetTransports(
- rtc::PacketTransportInternal* rtp_packet_transport,
- rtc::PacketTransportInternal* rtcp_packet_transport) {
- network_thread_->Invoke<void>(
- RTC_FROM_HERE, Bind(&BaseChannel::SetTransports_n, this, nullptr, nullptr,
- rtp_packet_transport, rtcp_packet_transport));
-}
-
-void BaseChannel::SetTransports_n(
- DtlsTransportInternal* rtp_dtls_transport,
- DtlsTransportInternal* rtcp_dtls_transport,
- rtc::PacketTransportInternal* rtp_packet_transport,
- rtc::PacketTransportInternal* rtcp_packet_transport) {
- RTC_DCHECK(network_thread_->IsCurrent());
- // Validate some assertions about the input.
- RTC_DCHECK(rtp_packet_transport);
- RTC_DCHECK_EQ(NeedsRtcpTransport(), rtcp_packet_transport != nullptr);
- if (rtp_dtls_transport || rtcp_dtls_transport) {
- // DTLS/non-DTLS pointers should be to the same object.
- RTC_DCHECK(rtp_dtls_transport == rtp_packet_transport);
- RTC_DCHECK(rtcp_dtls_transport == rtcp_packet_transport);
- // Can't go from non-DTLS to DTLS.
- RTC_DCHECK(!rtp_transport_->rtp_packet_transport() || rtp_dtls_transport_);
- } else {
- // Can't go from DTLS to non-DTLS.
- RTC_DCHECK(!rtp_dtls_transport_);
- }
- // Transport names should be the same.
- if (rtp_dtls_transport && rtcp_dtls_transport) {
- RTC_DCHECK(rtp_dtls_transport->transport_name() ==
- rtcp_dtls_transport->transport_name());
- }
-
- if (rtp_packet_transport == rtp_transport_->rtp_packet_transport()) {
- // Nothing to do if transport isn't changing.
- return;
- }
-
- std::string debug_name;
- if (rtp_dtls_transport) {
- transport_name_ = rtp_dtls_transport->transport_name();
- debug_name = transport_name_;
- } else {
- debug_name = rtp_packet_transport->transport_name();
- }
- // If this BaseChannel doesn't require RTCP mux and we haven't fully
- // negotiated RTCP mux, we need an RTCP transport.
- if (rtcp_packet_transport) {
- RTC_LOG(LS_INFO) << "Setting RTCP Transport for " << content_name()
- << " on " << debug_name << " transport "
- << rtcp_packet_transport;
- SetTransport_n(/*rtcp=*/true, rtcp_dtls_transport, rtcp_packet_transport);
- }
-
- RTC_LOG(LS_INFO) << "Setting RTP Transport for " << content_name() << " on "
- << debug_name << " transport " << rtp_packet_transport;
- SetTransport_n(/*rtcp=*/false, rtp_dtls_transport, rtp_packet_transport);
-
- // Set DtlsTransport/PacketTransport for RTP-level transport.
- if ((rtp_dtls_transport_ || rtcp_dtls_transport_) && dtls_srtp_transport_) {
- // When setting the transport with non-null |dtls_srtp_transport_|, we are
- // using DTLS-SRTP. This could happen for bundling. If the
- // |dtls_srtp_transport| is null, we cannot tell if it doing DTLS-SRTP or
- // SDES until the description is set. So don't call |EnableDtlsSrtp_n| here.
- dtls_srtp_transport_->SetDtlsTransports(rtp_dtls_transport,
- rtcp_dtls_transport);
- } else {
- rtp_transport_->SetRtpPacketTransport(rtp_packet_transport);
- rtp_transport_->SetRtcpPacketTransport(rtcp_packet_transport);
- }
-
- // Update aggregate writable/ready-to-send state between RTP and RTCP upon
- // setting new transport channels.
- UpdateWritableState_n();
-}
-
-void BaseChannel::SetTransport_n(
- bool rtcp,
- DtlsTransportInternal* new_dtls_transport,
- rtc::PacketTransportInternal* new_packet_transport) {
- RTC_DCHECK(network_thread_->IsCurrent());
- if (new_dtls_transport) {
- RTC_DCHECK(new_dtls_transport == new_packet_transport);
- }
- DtlsTransportInternal*& old_dtls_transport =
- rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
- rtc::PacketTransportInternal* old_packet_transport =
- rtcp ? rtp_transport_->rtcp_packet_transport()
- : rtp_transport_->rtp_packet_transport();
-
- if (!old_packet_transport && !new_packet_transport) {
- // Nothing to do.
- return;
- }
-
- RTC_DCHECK(old_packet_transport != new_packet_transport);
-
- old_dtls_transport = new_dtls_transport;
-
- // If there's no new transport, we're done.
- if (!new_packet_transport) {
- return;
- }
-
- if (rtcp && new_dtls_transport) {
- RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_active()))
- << "Setting RTCP for DTLS/SRTP after the DTLS is active "
- << "should never happen.";
- }
-
- auto& socket_options = rtcp ? rtcp_socket_options_ : socket_options_;
- for (const auto& pair : socket_options) {
- new_packet_transport->SetOption(pair.first, pair.second);
+ // Set the cached socket options.
+ for (const auto& pair : socket_options_) {
+ rtp_transport_->rtp_packet_transport()->SetOption(pair.first,
+ pair.second);
+ }
+ if (rtp_transport_->rtcp_packet_transport()) {
+ for (const auto& pair : rtcp_socket_options_) {
+ rtp_transport_->rtp_packet_transport()->SetOption(pair.first,
+ pair.second);
+ }
+ }
}
}
@@ -416,12 +277,6 @@
Bind(&BaseChannel::SetRemoteContent_w, this, content, type, error_desc));
}
-bool BaseChannel::NeedsRtcpTransport() {
- // If this BaseChannel doesn't require RTCP mux and we haven't fully
- // negotiated RTCP mux, we need an RTCP transport.
- return !rtcp_mux_required_ && !rtcp_mux_filter_.IsFullyActive();
-}
-
bool BaseChannel::IsReadyToReceiveMedia_w() const {
// Receive data if we are enabled and have local content,
return enabled() &&
@@ -440,7 +295,7 @@
return enabled() &&
webrtc::RtpTransceiverDirectionHasRecv(remote_content_direction_) &&
webrtc::RtpTransceiverDirectionHasSend(local_content_direction_) &&
- was_ever_writable() && (srtp_active() || !ShouldSetupDtlsSrtp_n());
+ was_ever_writable() && (srtp_active() || encryption_disabled_);
}
bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet,
@@ -463,6 +318,7 @@
rtc::Socket::Option opt,
int value) {
RTC_DCHECK(network_thread_->IsCurrent());
+ RTC_DCHECK(rtp_transport_);
rtc::PacketTransportInternal* transport = nullptr;
switch (type) {
case ST_RTP:
@@ -482,11 +338,6 @@
void BaseChannel::OnWritableState(bool writable) {
RTC_DCHECK(network_thread_->IsCurrent());
if (writable) {
- // This is used to cover the scenario when the DTLS handshake is completed
- // and DtlsTransport becomes writable before the remote description is set.
- if (ShouldSetupDtlsSrtp_n()) {
- EnableDtlsSrtp_n();
- }
ChannelWritable_n();
} else {
ChannelNotWritable_n();
@@ -533,13 +384,14 @@
network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
return true;
}
+
TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
// Now that we are on the correct thread, ensure we have a place to send this
// packet before doing anything. (We might get RTCP packets that we don't
// intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
// transport.
- if (!rtp_transport_->IsWritable(rtcp)) {
+ if (!rtp_transport_ || !rtp_transport_->IsWritable(rtcp)) {
return false;
}
@@ -571,18 +423,15 @@
std::string packet_type = rtcp ? "RTCP" : "RTP";
RTC_LOG(LS_WARNING) << "Sending an " << packet_type
<< " packet without encryption.";
- } else {
- // Make sure we didn't accidentally send any packets without encryption.
- RTC_DCHECK(rtp_transport_ == sdes_transport_.get() ||
- rtp_transport_ == dtls_srtp_transport_.get());
}
+
// Bon voyage.
return rtcp ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS)
: rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS);
}
bool BaseChannel::HandlesPayloadType(int packet_type) const {
- return rtp_transport_->HandlesPayloadType(packet_type);
+ return bundle_filter_.FindPayloadType(packet_type);
}
void BaseChannel::OnPacketReceived(bool rtcp,
@@ -593,6 +442,11 @@
signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
}
+ // Filter out the packet this channel cannot handle.
+ if (!rtcp && !bundle_filter_.DemuxPacket(packet->data(), packet->size())) {
+ return;
+ }
+
if (!srtp_active() && srtp_required_) {
// Our session description indicates that SRTP is required, but we got a
// packet before our SRTP filter is active. This means either that
@@ -652,12 +506,8 @@
}
void BaseChannel::UpdateWritableState_n() {
- rtc::PacketTransportInternal* rtp_packet_transport =
- rtp_transport_->rtp_packet_transport();
- rtc::PacketTransportInternal* rtcp_packet_transport =
- rtp_transport_->rtcp_packet_transport();
- if (rtp_packet_transport && rtp_packet_transport->writable() &&
- (!rtcp_packet_transport || rtcp_packet_transport->writable())) {
+ if (rtp_transport_->IsWritable(/*rtcp=*/true) &&
+ rtp_transport_->IsWritable(/*rtcp=*/false)) {
ChannelWritable_n();
} else {
ChannelNotWritable_n();
@@ -678,11 +528,6 @@
UpdateMediaSendRecvState();
}
-bool BaseChannel::ShouldSetupDtlsSrtp_n() const {
- // Since DTLS is applied to all transports, checking RTP should be enough.
- return rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
-}
-
void BaseChannel::ChannelNotWritable_n() {
RTC_DCHECK(network_thread_->IsCurrent());
if (!writable_)
@@ -693,238 +538,6 @@
UpdateMediaSendRecvState();
}
-bool BaseChannel::SetRtpTransportParameters(
- const MediaContentDescription* content,
- SdpType type,
- ContentSource src,
- const RtpHeaderExtensions& extensions,
- std::string* error_desc) {
- std::vector<int> encrypted_extension_ids;
- for (const webrtc::RtpExtension& extension : extensions) {
- if (extension.encrypt) {
- RTC_LOG(LS_INFO) << "Using " << (src == CS_LOCAL ? "local" : "remote")
- << " encrypted extension: " << extension.ToString();
- encrypted_extension_ids.push_back(extension.id);
- }
- }
-
- // Cache srtp_required_ for belt and suspenders check on SendPacket
- return network_thread_->Invoke<bool>(
- RTC_FROM_HERE,
- Bind(&BaseChannel::SetRtpTransportParameters_n, this, content, type, src,
- encrypted_extension_ids, error_desc));
-}
-
-bool BaseChannel::SetRtpTransportParameters_n(
- const MediaContentDescription* content,
- SdpType type,
- ContentSource src,
- const std::vector<int>& encrypted_extension_ids,
- std::string* error_desc) {
- RTC_DCHECK(network_thread_->IsCurrent());
-
- if (!SetSrtp_n(content->cryptos(), type, src, encrypted_extension_ids,
- error_desc)) {
- return false;
- }
-
- if (!SetRtcpMux_n(content->rtcp_mux(), type, src, error_desc)) {
- return false;
- }
-
- return true;
-}
-
-// |dtls| will be set to true if DTLS is active for transport and crypto is
-// empty.
-bool BaseChannel::CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos,
- bool* dtls,
- std::string* error_desc) {
- *dtls = rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
- if (*dtls && !cryptos.empty()) {
- SafeSetError("Cryptos must be empty when DTLS is active.", error_desc);
- return false;
- }
- return true;
-}
-
-void BaseChannel::EnableSdes_n() {
- if (sdes_transport_) {
- return;
- }
- // DtlsSrtpTransport and SrtpTransport shouldn't be enabled at the same
- // time.
- RTC_DCHECK(!dtls_srtp_transport_);
- RTC_DCHECK(unencrypted_rtp_transport_);
- sdes_transport_ = rtc::MakeUnique<webrtc::SrtpTransport>(
- std::move(unencrypted_rtp_transport_));
-#if defined(ENABLE_EXTERNAL_AUTH)
- sdes_transport_->EnableExternalAuth();
-#endif
- SetRtpTransport(sdes_transport_.get());
- RTC_LOG(LS_INFO) << "Wrapping RtpTransport in SrtpTransport.";
-}
-
-void BaseChannel::EnableDtlsSrtp_n() {
- if (dtls_srtp_transport_) {
- return;
- }
- // DtlsSrtpTransport and SrtpTransport shouldn't be enabled at the same
- // time.
- RTC_DCHECK(!sdes_transport_);
- RTC_DCHECK(unencrypted_rtp_transport_);
-
- auto srtp_transport = rtc::MakeUnique<webrtc::SrtpTransport>(
- std::move(unencrypted_rtp_transport_));
-#if defined(ENABLE_EXTERNAL_AUTH)
- srtp_transport->EnableExternalAuth();
-#endif
- dtls_srtp_transport_ =
- rtc::MakeUnique<webrtc::DtlsSrtpTransport>(std::move(srtp_transport));
-
- SetRtpTransport(dtls_srtp_transport_.get());
- if (cached_send_extension_ids_) {
- dtls_srtp_transport_->UpdateSendEncryptedHeaderExtensionIds(
- *cached_send_extension_ids_);
- }
- if (cached_recv_extension_ids_) {
- dtls_srtp_transport_->UpdateRecvEncryptedHeaderExtensionIds(
- *cached_recv_extension_ids_);
- }
- // Set the DtlsTransport and the |dtls_srtp_transport_| will handle the DTLS
- // relate signal internally.
- RTC_DCHECK(rtp_dtls_transport_);
- dtls_srtp_transport_->SetDtlsTransports(rtp_dtls_transport_,
- rtcp_dtls_transport_);
-
- RTC_LOG(LS_INFO) << "Wrapping SrtpTransport in DtlsSrtpTransport.";
-}
-
-bool BaseChannel::SetSrtp_n(const std::vector<CryptoParams>& cryptos,
- SdpType type,
- ContentSource src,
- const std::vector<int>& encrypted_extension_ids,
- std::string* error_desc) {
- TRACE_EVENT0("webrtc", "BaseChannel::SetSrtp_w");
- bool ret = false;
- bool dtls = false;
- ret = CheckSrtpConfig_n(cryptos, &dtls, error_desc);
- if (!ret) {
- return false;
- }
-
- // If SRTP was not required, but we're setting a description that uses SDES,
- // we need to upgrade to an SrtpTransport.
- if (!sdes_transport_ && !dtls && !cryptos.empty()) {
- EnableSdes_n();
- }
-
- if ((type == SdpType::kAnswer || type == SdpType::kPrAnswer) && dtls) {
- EnableDtlsSrtp_n();
- }
-
- UpdateEncryptedHeaderExtensionIds(src, encrypted_extension_ids);
-
- if (!dtls) {
- switch (type) {
- case SdpType::kOffer:
- ret = sdes_negotiator_.SetOffer(cryptos, src);
- break;
- case SdpType::kPrAnswer:
- ret = sdes_negotiator_.SetProvisionalAnswer(cryptos, src);
- break;
- case SdpType::kAnswer:
- ret = sdes_negotiator_.SetAnswer(cryptos, src);
- break;
- default:
- break;
- }
-
- // If setting an SDES answer succeeded, apply the negotiated parameters
- // to the SRTP transport.
- if ((type == SdpType::kPrAnswer || type == SdpType::kAnswer) && ret) {
- if (sdes_negotiator_.send_cipher_suite() &&
- sdes_negotiator_.recv_cipher_suite()) {
- RTC_DCHECK(cached_send_extension_ids_);
- RTC_DCHECK(cached_recv_extension_ids_);
- ret = sdes_transport_->SetRtpParams(
- *(sdes_negotiator_.send_cipher_suite()),
- sdes_negotiator_.send_key().data(),
- static_cast<int>(sdes_negotiator_.send_key().size()),
- *(cached_send_extension_ids_),
- *(sdes_negotiator_.recv_cipher_suite()),
- sdes_negotiator_.recv_key().data(),
- static_cast<int>(sdes_negotiator_.recv_key().size()),
- *(cached_recv_extension_ids_));
- } else {
- RTC_LOG(LS_INFO) << "No crypto keys are provided for SDES.";
- if (type == SdpType::kAnswer && sdes_transport_) {
- // Explicitly reset the |sdes_transport_| if no crypto param is
- // provided in the answer. No need to call |ResetParams()| for
- // |sdes_negotiator_| because it resets the params inside |SetAnswer|.
- sdes_transport_->ResetParams();
- }
- }
- }
- }
-
- if (!ret) {
- SafeSetError("Failed to setup SRTP.", error_desc);
- return false;
- }
- return true;
-}
-
-bool BaseChannel::SetRtcpMux_n(bool enable,
- SdpType type,
- ContentSource src,
- std::string* error_desc) {
- // Provide a more specific error message for the RTCP mux "require" policy
- // case.
- if (rtcp_mux_required_ && !enable) {
- SafeSetError(
- "rtcpMuxPolicy is 'require', but media description does not "
- "contain 'a=rtcp-mux'.",
- error_desc);
- return false;
- }
- bool ret = false;
- switch (type) {
- case SdpType::kOffer:
- ret = rtcp_mux_filter_.SetOffer(enable, src);
- break;
- case SdpType::kPrAnswer:
- // This may activate RTCP muxing, but we don't yet destroy the transport
- // because the final answer may deactivate it.
- ret = rtcp_mux_filter_.SetProvisionalAnswer(enable, src);
- break;
- case SdpType::kAnswer:
- ret = rtcp_mux_filter_.SetAnswer(enable, src);
- if (ret && rtcp_mux_filter_.IsActive()) {
- ActivateRtcpMux();
- }
- break;
- default:
- break;
- }
- if (!ret) {
- SafeSetError("Failed to setup RTCP mux filter.", error_desc);
- return false;
- }
- rtp_transport_->SetRtcpMuxEnabled(rtcp_mux_filter_.IsActive());
- // |rtcp_mux_filter_| can be active if |action| is SdpType::kPrAnswer or
- // SdpType::kAnswer, but we only want to tear down the RTCP transport if we
- // received a final answer.
- if (rtcp_mux_filter_.IsActive()) {
- // If the RTP transport is already writable, then so are we.
- if (rtp_transport_->rtp_packet_transport()->writable()) {
- ChannelWritable_n();
- }
- }
-
- return true;
-}
-
bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
RTC_DCHECK(worker_thread() == rtc::Thread::Current());
return media_channel()->AddRecvStream(sp);
@@ -1008,9 +621,8 @@
RtpHeaderExtensions BaseChannel::GetFilteredRtpHeaderExtensions(
const RtpHeaderExtensions& extensions) {
- if (!rtp_dtls_transport_ ||
- !rtp_dtls_transport_->crypto_options()
- .enable_encrypted_rtp_header_extensions) {
+ RTC_DCHECK(rtp_transport_);
+ if (crypto_options_.enable_encrypted_rtp_header_extensions) {
RtpHeaderExtensions filtered;
auto pred = [](const webrtc::RtpExtension& extension) {
return !extension.encrypt;
@@ -1023,39 +635,6 @@
return webrtc::RtpExtension::FilterDuplicateNonEncrypted(extensions);
}
-void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension_w(
- const std::vector<webrtc::RtpExtension>& extensions) {
-// Absolute Send Time extension id is used only with external auth,
-// so do not bother searching for it and making asyncronious call to set
-// something that is not used.
-#if defined(ENABLE_EXTERNAL_AUTH)
- const webrtc::RtpExtension* send_time_extension =
- webrtc::RtpExtension::FindHeaderExtensionByUri(
- extensions, webrtc::RtpExtension::kAbsSendTimeUri);
- int rtp_abs_sendtime_extn_id =
- send_time_extension ? send_time_extension->id : -1;
- invoker_.AsyncInvoke<void>(
- RTC_FROM_HERE, network_thread_,
- Bind(&BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n, this,
- rtp_abs_sendtime_extn_id));
-#endif
-}
-
-void BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n(
- int rtp_abs_sendtime_extn_id) {
- if (sdes_transport_) {
- sdes_transport_->CacheRtpAbsSendTimeHeaderExtension(
- rtp_abs_sendtime_extn_id);
- } else if (dtls_srtp_transport_) {
- dtls_srtp_transport_->CacheRtpAbsSendTimeHeaderExtension(
- rtp_abs_sendtime_extn_id);
- } else {
- RTC_LOG(LS_WARNING)
- << "Trying to cache the Absolute Send Time extension id "
- "but the SRTP is not active.";
- }
-}
-
void BaseChannel::OnMessage(rtc::Message *pmsg) {
TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
switch (pmsg->message_id) {
@@ -1077,7 +656,7 @@
}
void BaseChannel::AddHandledPayloadType(int payload_type) {
- rtp_transport_->AddHandledPayloadType(payload_type);
+ bundle_filter_.AddPayloadType(payload_type);
}
void BaseChannel::FlushRtcpMessages_n() {
@@ -1104,47 +683,6 @@
SignalSentPacket(sent_packet);
}
-void BaseChannel::UpdateEncryptedHeaderExtensionIds(
- cricket::ContentSource source,
- const std::vector<int>& extension_ids) {
- if (source == ContentSource::CS_LOCAL) {
- cached_recv_extension_ids_ = std::move(extension_ids);
- if (dtls_srtp_transport_) {
- dtls_srtp_transport_->UpdateRecvEncryptedHeaderExtensionIds(
- extension_ids);
- }
- } else {
- cached_send_extension_ids_ = std::move(extension_ids);
- if (dtls_srtp_transport_) {
- dtls_srtp_transport_->UpdateSendEncryptedHeaderExtensionIds(
- extension_ids);
- }
- }
-}
-
-void BaseChannel::ActivateRtcpMux() {
- // We permanently activated RTCP muxing; signal that we no longer need
- // the RTCP transport.
- std::string debug_name =
- transport_name_.empty()
- ? rtp_transport_->rtp_packet_transport()->transport_name()
- : transport_name_;
- RTC_LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
- << "; no longer need RTCP transport for " << debug_name;
- if (rtp_transport_->rtcp_packet_transport()) {
- SetTransport_n(/*rtcp=*/true, nullptr, nullptr);
- if (dtls_srtp_transport_) {
- RTC_DCHECK(rtp_dtls_transport_);
- dtls_srtp_transport_->SetDtlsTransports(rtp_dtls_transport_,
- /*rtcp_dtls_transport_=*/nullptr);
- } else {
- rtp_transport_->SetRtcpPacketTransport(nullptr);
- }
- SignalRtcpMuxFullyActive(transport_name_);
- }
- UpdateWritableState_n();
-}
-
VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
@@ -1152,21 +690,20 @@
MediaEngineInterface* /* media_engine */,
std::unique_ptr<VoiceMediaChannel> media_channel,
const std::string& content_name,
- bool rtcp_mux_required,
- bool srtp_required)
+ bool srtp_required,
+ rtc::CryptoOptions crypto_options)
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
std::move(media_channel),
content_name,
- rtcp_mux_required,
- srtp_required) {}
+ srtp_required,
+ crypto_options) {}
VoiceChannel::~VoiceChannel() {
TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
// this can't be done in the base class, since it calls a virtual
DisableMedia_w();
- Deinit();
}
void BaseChannel::UpdateMediaSendRecvState() {
@@ -1208,11 +745,6 @@
RtpHeaderExtensions rtp_header_extensions =
GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
- if (!SetRtpTransportParameters(content, type, CS_LOCAL, rtp_header_extensions,
- error_desc)) {
- return false;
- }
-
AudioRecvParameters recv_params = last_recv_params_;
RtpParametersFromMediaDescription(audio, rtp_header_extensions, &recv_params);
if (!media_channel()->SetRecvParameters(recv_params)) {
@@ -1257,11 +789,6 @@
RtpHeaderExtensions rtp_header_extensions =
GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
- if (!SetRtpTransportParameters(content, type, CS_REMOTE,
- rtp_header_extensions, error_desc)) {
- return false;
- }
-
AudioSendParameters send_params = last_send_params_;
RtpSendParametersFromMediaDescription(audio, rtp_header_extensions,
&send_params);
@@ -1284,10 +811,6 @@
return false;
}
- if (audio->rtp_header_extensions_set()) {
- MaybeCacheRtpAbsSendTimeHeaderExtension_w(rtp_header_extensions);
- }
-
set_remote_content_direction(content->direction());
UpdateMediaSendRecvState_w();
return true;
@@ -1298,22 +821,20 @@
rtc::Thread* signaling_thread,
std::unique_ptr<VideoMediaChannel> media_channel,
const std::string& content_name,
- bool rtcp_mux_required,
- bool srtp_required)
+ bool srtp_required,
+ rtc::CryptoOptions crypto_options)
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
std::move(media_channel),
content_name,
- rtcp_mux_required,
- srtp_required) {}
+ srtp_required,
+ crypto_options) {}
VideoChannel::~VideoChannel() {
TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
// this can't be done in the base class, since it calls a virtual
DisableMedia_w();
-
- Deinit();
}
void VideoChannel::UpdateMediaSendRecvState_w() {
@@ -1351,11 +872,6 @@
RtpHeaderExtensions rtp_header_extensions =
GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
- if (!SetRtpTransportParameters(content, type, CS_LOCAL, rtp_header_extensions,
- error_desc)) {
- return false;
- }
-
VideoRecvParameters recv_params = last_recv_params_;
RtpParametersFromMediaDescription(video, rtp_header_extensions, &recv_params);
if (!media_channel()->SetRecvParameters(recv_params)) {
@@ -1400,11 +916,6 @@
RtpHeaderExtensions rtp_header_extensions =
GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
- if (!SetRtpTransportParameters(content, type, CS_REMOTE,
- rtp_header_extensions, error_desc)) {
- return false;
- }
-
VideoSendParameters send_params = last_send_params_;
RtpSendParametersFromMediaDescription(video, rtp_header_extensions,
&send_params);
@@ -1430,11 +941,6 @@
SafeSetError("Failed to set remote video description streams.", error_desc);
return false;
}
-
- if (video->rtp_header_extensions_set()) {
- MaybeCacheRtpAbsSendTimeHeaderExtension_w(rtp_header_extensions);
- }
-
set_remote_content_direction(content->direction());
UpdateMediaSendRecvState_w();
return true;
@@ -1445,36 +951,20 @@
rtc::Thread* signaling_thread,
std::unique_ptr<DataMediaChannel> media_channel,
const std::string& content_name,
- bool rtcp_mux_required,
- bool srtp_required)
+ bool srtp_required,
+ rtc::CryptoOptions crypto_options)
: BaseChannel(worker_thread,
network_thread,
signaling_thread,
std::move(media_channel),
content_name,
- rtcp_mux_required,
- srtp_required) {}
+ srtp_required,
+ crypto_options) {}
RtpDataChannel::~RtpDataChannel() {
TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel");
// this can't be done in the base class, since it calls a virtual
DisableMedia_w();
-
- Deinit();
-}
-
-void RtpDataChannel::Init_w(
- DtlsTransportInternal* rtp_dtls_transport,
- DtlsTransportInternal* rtcp_dtls_transport,
- rtc::PacketTransportInternal* rtp_packet_transport,
- rtc::PacketTransportInternal* rtcp_packet_transport) {
- BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
- rtp_packet_transport, rtcp_packet_transport);
-
- media_channel()->SignalDataReceived.connect(this,
- &RtpDataChannel::OnDataReceived);
- media_channel()->SignalReadyToSend.connect(
- this, &RtpDataChannel::OnDataChannelReadyToSend);
}
void RtpDataChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
@@ -1529,11 +1019,6 @@
RtpHeaderExtensions rtp_header_extensions =
GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
- if (!SetRtpTransportParameters(content, type, CS_LOCAL, rtp_header_extensions,
- error_desc)) {
- return false;
- }
-
DataRecvParameters recv_params = last_recv_params_;
RtpParametersFromMediaDescription(data, rtp_header_extensions, &recv_params);
if (!media_channel()->SetRecvParameters(recv_params)) {
@@ -1588,11 +1073,6 @@
GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
RTC_LOG(LS_INFO) << "Setting remote data description";
- if (!SetRtpTransportParameters(content, type, CS_REMOTE,
- rtp_header_extensions, error_desc)) {
- return false;
- }
-
DataSendParameters send_params = last_send_params_;
RtpSendParametersFromMediaDescription<DataCodec>(data, rtp_header_extensions,
&send_params);
