From b4c1f2f6fc28889bcc2091106e2dfa922431d716 Mon Sep 17 00:00:00 2001 From: Per K Date: Thu, 29 Aug 2024 14:59:23 +0000 Subject: [PATCH] Remove DegradedCall - To be submitted after 2024-07-01 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:343801362 Change-Id: Icae19ab2f4c87521483d25ae8d44c849c5f8ed2e Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/353140 Commit-Queue: Per Kjellander Reviewed-by: Harald Alvestrand Reviewed-by: Florent Castelli Reviewed-by: Erik Språng Cr-Commit-Position: refs/heads/main@{#42892} --- api/BUILD.gn | 1 - api/enable_media.cc | 3 +- call/BUILD.gn | 4 - call/create_call.cc | 61 ---- call/create_call.h | 25 -- call/degraded_call.cc | 380 ------------------------ call/degraded_call.h | 201 ------------- pc/peer_connection_field_trial_tests.cc | 69 ----- 8 files changed, 1 insertion(+), 743 deletions(-) delete mode 100644 call/create_call.h delete mode 100644 call/degraded_call.cc delete mode 100644 call/degraded_call.h diff --git a/api/BUILD.gn b/api/BUILD.gn index 419ebc1785..53e4caaf8d 100644 --- a/api/BUILD.gn +++ b/api/BUILD.gn @@ -37,7 +37,6 @@ rtc_source_set("enable_media") { ":scoped_refptr", "../call", "../call:call_interfaces", - "../call:call_interfaces", "../media:media_engine", "../media:rtc_audio_video", "../pc:media_factory", diff --git a/api/enable_media.cc b/api/enable_media.cc index 6ef354b60b..233de7910f 100644 --- a/api/enable_media.cc +++ b/api/enable_media.cc @@ -18,7 +18,6 @@ #include "api/scoped_refptr.h" #include "call/call.h" #include "call/call_config.h" -#include "call/create_call.h" #include "media/base/media_engine.h" #include "media/engine/webrtc_video_engine.h" #include "media/engine/webrtc_voice_engine.h" @@ -40,7 +39,7 @@ class MediaFactoryImpl : public MediaFactory { ~MediaFactoryImpl() override = default; std::unique_ptr CreateCall(CallConfig config) override { - return webrtc::CreateCall(std::move(config)); + return webrtc::Call::Create(std::move(config)); } std::unique_ptr CreateMediaEngine( diff --git a/call/BUILD.gn b/call/BUILD.gn index d4c1d564e3..4bc51922e9 100644 --- a/call/BUILD.gn +++ b/call/BUILD.gn @@ -269,10 +269,6 @@ rtc_library("bitrate_allocator") { rtc_library("call") { sources = [ "call.cc", - "create_call.cc", - "create_call.h", - "degraded_call.cc", - "degraded_call.h", "flexfec_receive_stream_impl.cc", "flexfec_receive_stream_impl.h", "receive_time_calculator.cc", diff --git a/call/create_call.cc b/call/create_call.cc index 317a187423..573033e7bf 100644 --- a/call/create_call.cc +++ b/call/create_call.cc @@ -10,72 +10,11 @@ #include "call/create_call.h" -#include - #include -#include -#include -#include -#include "absl/types/optional.h" -#include "api/test/simulated_network.h" -#include "api/units/time_delta.h" #include "call/call.h" -#include "call/degraded_call.h" -#include "rtc_base/checks.h" -#include "rtc_base/experiments/field_trial_list.h" -#include "rtc_base/experiments/field_trial_parser.h" namespace webrtc { -namespace { -using TimeScopedNetworkConfig = DegradedCall::TimeScopedNetworkConfig; - -std::vector GetNetworkConfigs( - const FieldTrialsView& trials, - bool send) { - FieldTrialStructList trials_list( - {FieldTrialStructMember("queue_length_packets", - [](TimeScopedNetworkConfig* p) { - // FieldTrialParser does not natively support - // size_t type, so use this ugly cast as - // workaround. - return reinterpret_cast( - &p->queue_length_packets); - }), - FieldTrialStructMember( - "queue_delay_ms", - [](TimeScopedNetworkConfig* p) { return &p->queue_delay_ms; }), - FieldTrialStructMember("delay_standard_deviation_ms", - [](TimeScopedNetworkConfig* p) { - return &p->delay_standard_deviation_ms; - }), - FieldTrialStructMember( - "link_capacity_kbps", - [](TimeScopedNetworkConfig* p) { return &p->link_capacity_kbps; }), - FieldTrialStructMember( - "loss_percent", - [](TimeScopedNetworkConfig* p) { return &p->loss_percent; }), - FieldTrialStructMember( - "allow_reordering", - [](TimeScopedNetworkConfig* p) { return &p->allow_reordering; }), - FieldTrialStructMember("avg_burst_loss_length", - [](TimeScopedNetworkConfig* p) { - return &p->avg_burst_loss_length; - }), - FieldTrialStructMember( - "packet_overhead", - [](TimeScopedNetworkConfig* p) { return &p->packet_overhead; }), - FieldTrialStructMember( - "duration", - [](TimeScopedNetworkConfig* p) { return &p->duration; })}, - {}); - ParseFieldTrial({&trials_list}, - trials.Lookup(send ? "WebRTC-FakeNetworkSendConfig" - : "WebRTC-FakeNetworkReceiveConfig")); - return trials_list.Get(); -} - -} // namespace std::unique_ptr CreateCall(CallConfig config) { std::vector send_degradation_configs = diff --git a/call/create_call.h b/call/create_call.h deleted file mode 100644 index c1b7e9ecf8..0000000000 --- a/call/create_call.h +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright 2017 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. - */ - -#ifndef CALL_CREATE_CALL_H_ -#define CALL_CREATE_CALL_H_ - -#include - -#include "call/call.h" -#include "call/call_config.h" - -namespace webrtc { - -std::unique_ptr CreateCall(CallConfig config); - -} // namespace webrtc - -#endif // CALL_CREATE_CALL_H_ diff --git a/call/degraded_call.cc b/call/degraded_call.cc deleted file mode 100644 index a511eda7bd..0000000000 --- a/call/degraded_call.cc +++ /dev/null @@ -1,380 +0,0 @@ -/* - * Copyright (c) 2018 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. - */ - -#include "call/degraded_call.h" - -#include -#include - -#include "absl/strings/string_view.h" -#include "api/sequence_checker.h" -#include "modules/rtp_rtcp/source/rtp_util.h" -#include "rtc_base/thread.h" - -namespace webrtc { - -DegradedCall::FakeNetworkPipeOnTaskQueue::FakeNetworkPipeOnTaskQueue( - TaskQueueBase* task_queue, - rtc::scoped_refptr call_alive, - Clock* clock, - std::unique_ptr network_behavior) - : clock_(clock), - task_queue_(task_queue), - call_alive_(std::move(call_alive)), - pipe_(clock, std::move(network_behavior)) {} - -void DegradedCall::FakeNetworkPipeOnTaskQueue::SendRtp( - rtc::ArrayView packet, - const PacketOptions& options, - Transport* transport) { - pipe_.SendRtp(packet, options, transport); - Process(); -} - -void DegradedCall::FakeNetworkPipeOnTaskQueue::SendRtcp( - rtc::ArrayView packet, - Transport* transport) { - pipe_.SendRtcp(packet, transport); - Process(); -} - -void DegradedCall::FakeNetworkPipeOnTaskQueue::AddActiveTransport( - Transport* transport) { - pipe_.AddActiveTransport(transport); -} - -void DegradedCall::FakeNetworkPipeOnTaskQueue::RemoveActiveTransport( - Transport* transport) { - pipe_.RemoveActiveTransport(transport); -} - -bool DegradedCall::FakeNetworkPipeOnTaskQueue::Process() { - pipe_.Process(); - auto time_to_next = pipe_.TimeUntilNextProcess(); - if (!time_to_next) { - // Packet was probably sent immediately. - return false; - } - - task_queue_->PostTask(SafeTask(call_alive_, [this, time_to_next] { - RTC_DCHECK_RUN_ON(task_queue_); - int64_t next_process_time = *time_to_next + clock_->TimeInMilliseconds(); - if (!next_process_ms_ || next_process_time < *next_process_ms_) { - next_process_ms_ = next_process_time; - task_queue_->PostDelayedHighPrecisionTask( - SafeTask(call_alive_, - [this] { - RTC_DCHECK_RUN_ON(task_queue_); - if (!Process()) { - next_process_ms_.reset(); - } - }), - TimeDelta::Millis(*time_to_next)); - } - })); - - return true; -} - -DegradedCall::FakeNetworkPipeTransportAdapter::FakeNetworkPipeTransportAdapter( - FakeNetworkPipeOnTaskQueue* fake_network, - Call* call, - Clock* clock, - Transport* real_transport) - : network_pipe_(fake_network), - call_(call), - clock_(clock), - real_transport_(real_transport) { - network_pipe_->AddActiveTransport(real_transport); -} - -DegradedCall::FakeNetworkPipeTransportAdapter:: - ~FakeNetworkPipeTransportAdapter() { - network_pipe_->RemoveActiveTransport(real_transport_); -} - -bool DegradedCall::FakeNetworkPipeTransportAdapter::SendRtp( - rtc::ArrayView packet, - const PacketOptions& options) { - // A call here comes from the RTP stack (probably pacer). We intercept it and - // put it in the fake network pipe instead, but report to Call that is has - // been sent, so that the bandwidth estimator sees the delay we add. - network_pipe_->SendRtp(packet, options, real_transport_); - if (options.packet_id != -1) { - rtc::SentPacket sent_packet; - sent_packet.packet_id = options.packet_id; - sent_packet.send_time_ms = clock_->TimeInMilliseconds(); - sent_packet.info.included_in_feedback = options.included_in_feedback; - sent_packet.info.included_in_allocation = options.included_in_allocation; - sent_packet.info.packet_size_bytes = packet.size(); - sent_packet.info.packet_type = rtc::PacketType::kData; - call_->OnSentPacket(sent_packet); - } - return true; -} - -bool DegradedCall::FakeNetworkPipeTransportAdapter::SendRtcp( - rtc::ArrayView packet) { - network_pipe_->SendRtcp(packet, real_transport_); - return true; -} - -DegradedCall::DegradedCall( - std::unique_ptr call, - const std::vector& send_configs, - const std::vector& receive_configs) - : clock_(Clock::GetRealTimeClock()), - call_(std::move(call)), - call_alive_(PendingTaskSafetyFlag::CreateDetached()), - send_config_index_(0), - send_configs_(send_configs), - send_simulated_network_(nullptr), - receive_config_index_(0), - receive_configs_(receive_configs) { - if (!receive_configs_.empty()) { - auto network = std::make_unique(receive_configs_[0]); - receive_simulated_network_ = network.get(); - receive_pipe_ = - std::make_unique(clock_, std::move(network)); - receive_pipe_->SetReceiver(call_->Receiver()); - if (receive_configs_.size() > 1) { - call_->network_thread()->PostDelayedTask( - SafeTask(call_alive_, [this] { UpdateReceiveNetworkConfig(); }), - receive_configs_[0].duration); - } - } - if (!send_configs_.empty()) { - auto network = std::make_unique(send_configs_[0]); - send_simulated_network_ = network.get(); - send_pipe_ = std::make_unique( - call_->network_thread(), call_alive_, clock_, std::move(network)); - if (send_configs_.size() > 1) { - call_->network_thread()->PostDelayedTask( - SafeTask(call_alive_, [this] { UpdateSendNetworkConfig(); }), - send_configs_[0].duration); - } - } -} - -DegradedCall::~DegradedCall() { - RTC_DCHECK_RUN_ON(call_->worker_thread()); - // Thread synchronization is required to call `SetNotAlive`. - // Otherwise, when the `DegradedCall` object is destroyed but - // `SetNotAlive` has not yet been called, - // another Closure guarded by `call_alive_` may be called. - // TODO(https://crbug.com/webrtc/12649): Remove this block-invoke. - static_cast(call_->network_thread()) - ->BlockingCall( - [flag = std::move(call_alive_)]() mutable { flag->SetNotAlive(); }); -} - -AudioSendStream* DegradedCall::CreateAudioSendStream( - const AudioSendStream::Config& config) { - if (!send_configs_.empty()) { - auto transport_adapter = std::make_unique( - send_pipe_.get(), call_.get(), clock_, config.send_transport); - AudioSendStream::Config degrade_config = config; - degrade_config.send_transport = transport_adapter.get(); - AudioSendStream* send_stream = call_->CreateAudioSendStream(degrade_config); - if (send_stream) { - audio_send_transport_adapters_[send_stream] = - std::move(transport_adapter); - } - return send_stream; - } - return call_->CreateAudioSendStream(config); -} - -void DegradedCall::DestroyAudioSendStream(AudioSendStream* send_stream) { - call_->DestroyAudioSendStream(send_stream); - audio_send_transport_adapters_.erase(send_stream); -} - -AudioReceiveStreamInterface* DegradedCall::CreateAudioReceiveStream( - const AudioReceiveStreamInterface::Config& config) { - return call_->CreateAudioReceiveStream(config); -} - -void DegradedCall::DestroyAudioReceiveStream( - AudioReceiveStreamInterface* receive_stream) { - call_->DestroyAudioReceiveStream(receive_stream); -} - -VideoSendStream* DegradedCall::CreateVideoSendStream( - VideoSendStream::Config config, - VideoEncoderConfig encoder_config) { - std::unique_ptr transport_adapter; - if (!send_configs_.empty()) { - transport_adapter = std::make_unique( - send_pipe_.get(), call_.get(), clock_, config.send_transport); - config.send_transport = transport_adapter.get(); - } - VideoSendStream* send_stream = call_->CreateVideoSendStream( - std::move(config), std::move(encoder_config)); - if (send_stream && transport_adapter) { - video_send_transport_adapters_[send_stream] = std::move(transport_adapter); - } - return send_stream; -} - -VideoSendStream* DegradedCall::CreateVideoSendStream( - VideoSendStream::Config config, - VideoEncoderConfig encoder_config, - std::unique_ptr fec_controller) { - std::unique_ptr transport_adapter; - if (!send_configs_.empty()) { - transport_adapter = std::make_unique( - send_pipe_.get(), call_.get(), clock_, config.send_transport); - config.send_transport = transport_adapter.get(); - } - VideoSendStream* send_stream = call_->CreateVideoSendStream( - std::move(config), std::move(encoder_config), std::move(fec_controller)); - if (send_stream && transport_adapter) { - video_send_transport_adapters_[send_stream] = std::move(transport_adapter); - } - return send_stream; -} - -void DegradedCall::DestroyVideoSendStream(VideoSendStream* send_stream) { - call_->DestroyVideoSendStream(send_stream); - video_send_transport_adapters_.erase(send_stream); -} - -VideoReceiveStreamInterface* DegradedCall::CreateVideoReceiveStream( - VideoReceiveStreamInterface::Config configuration) { - return call_->CreateVideoReceiveStream(std::move(configuration)); -} - -void DegradedCall::DestroyVideoReceiveStream( - VideoReceiveStreamInterface* receive_stream) { - call_->DestroyVideoReceiveStream(receive_stream); -} - -FlexfecReceiveStream* DegradedCall::CreateFlexfecReceiveStream( - const FlexfecReceiveStream::Config config) { - return call_->CreateFlexfecReceiveStream(std::move(config)); -} - -void DegradedCall::DestroyFlexfecReceiveStream( - FlexfecReceiveStream* receive_stream) { - call_->DestroyFlexfecReceiveStream(receive_stream); -} - -void DegradedCall::AddAdaptationResource( - rtc::scoped_refptr resource) { - call_->AddAdaptationResource(std::move(resource)); -} - -PacketReceiver* DegradedCall::Receiver() { - if (!receive_configs_.empty()) { - return this; - } - return call_->Receiver(); -} - -RtpTransportControllerSendInterface* -DegradedCall::GetTransportControllerSend() { - return call_->GetTransportControllerSend(); -} - -Call::Stats DegradedCall::GetStats() const { - return call_->GetStats(); -} - -const FieldTrialsView& DegradedCall::trials() const { - return call_->trials(); -} - -TaskQueueBase* DegradedCall::network_thread() const { - return call_->network_thread(); -} - -TaskQueueBase* DegradedCall::worker_thread() const { - return call_->worker_thread(); -} - -void DegradedCall::SignalChannelNetworkState(MediaType media, - NetworkState state) { - call_->SignalChannelNetworkState(media, state); -} - -void DegradedCall::OnAudioTransportOverheadChanged( - int transport_overhead_per_packet) { - call_->OnAudioTransportOverheadChanged(transport_overhead_per_packet); -} - -void DegradedCall::OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream, - uint32_t local_ssrc) { - call_->OnLocalSsrcUpdated(stream, local_ssrc); -} - -void DegradedCall::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream, - uint32_t local_ssrc) { - call_->OnLocalSsrcUpdated(stream, local_ssrc); -} - -void DegradedCall::OnLocalSsrcUpdated(FlexfecReceiveStream& stream, - uint32_t local_ssrc) { - call_->OnLocalSsrcUpdated(stream, local_ssrc); -} - -void DegradedCall::OnUpdateSyncGroup(AudioReceiveStreamInterface& stream, - absl::string_view sync_group) { - call_->OnUpdateSyncGroup(stream, sync_group); -} - -void DegradedCall::OnSentPacket(const rtc::SentPacket& sent_packet) { - if (!send_configs_.empty()) { - // If we have a degraded send-transport, we have already notified call - // about the supposed network send time. Discard the actual network send - // time in order to properly fool the BWE. - return; - } - call_->OnSentPacket(sent_packet); -} - -void DegradedCall::DeliverRtpPacket( - MediaType media_type, - RtpPacketReceived packet, - OnUndemuxablePacketHandler undemuxable_packet_handler) { - RTC_DCHECK_RUN_ON(&received_packet_sequence_checker_); - receive_pipe_->DeliverRtpPacket(media_type, std::move(packet), - std::move(undemuxable_packet_handler)); - receive_pipe_->Process(); -} - -void DegradedCall::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) { - RTC_DCHECK_RUN_ON(&received_packet_sequence_checker_); - receive_pipe_->DeliverRtcpPacket(std::move(packet)); - receive_pipe_->Process(); -} - -void DegradedCall::SetClientBitratePreferences( - const webrtc::BitrateSettings& preferences) { - call_->SetClientBitratePreferences(preferences); -} - -void DegradedCall::UpdateSendNetworkConfig() { - send_config_index_ = (send_config_index_ + 1) % send_configs_.size(); - send_simulated_network_->SetConfig(send_configs_[send_config_index_]); - call_->network_thread()->PostDelayedTask( - SafeTask(call_alive_, [this] { UpdateSendNetworkConfig(); }), - send_configs_[send_config_index_].duration); -} - -void DegradedCall::UpdateReceiveNetworkConfig() { - receive_config_index_ = (receive_config_index_ + 1) % receive_configs_.size(); - receive_simulated_network_->SetConfig( - receive_configs_[receive_config_index_]); - call_->network_thread()->PostDelayedTask( - SafeTask(call_alive_, [this] { UpdateReceiveNetworkConfig(); }), - receive_configs_[receive_config_index_].duration); -} -} // namespace webrtc diff --git a/call/degraded_call.h b/call/degraded_call.h deleted file mode 100644 index 2a158bd112..0000000000 --- a/call/degraded_call.h +++ /dev/null @@ -1,201 +0,0 @@ -/* - * Copyright (c) 2018 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. - */ - -#ifndef CALL_DEGRADED_CALL_H_ -#define CALL_DEGRADED_CALL_H_ - -#include -#include - -#include -#include -#include -#include - -#include "absl/strings/string_view.h" -#include "absl/types/optional.h" -#include "api/call/transport.h" -#include "api/fec_controller.h" -#include "api/media_types.h" -#include "api/rtp_headers.h" -#include "api/task_queue/pending_task_safety_flag.h" -#include "api/test/simulated_network.h" -#include "call/audio_receive_stream.h" -#include "call/audio_send_stream.h" -#include "call/call.h" -#include "call/fake_network_pipe.h" -#include "call/flexfec_receive_stream.h" -#include "call/packet_receiver.h" -#include "call/rtp_transport_controller_send_interface.h" -#include "call/video_receive_stream.h" -#include "call/video_send_stream.h" -#include "rtc_base/copy_on_write_buffer.h" -#include "rtc_base/network/sent_packet.h" -#include "system_wrappers/include/clock.h" -#include "test/network/simulated_network.h" -#include "video/config/video_encoder_config.h" - -namespace webrtc { -class DegradedCall : public Call, private PacketReceiver { - public: - struct TimeScopedNetworkConfig : public BuiltInNetworkBehaviorConfig { - TimeDelta duration = TimeDelta::PlusInfinity(); - }; - - explicit DegradedCall( - std::unique_ptr call, - const std::vector& send_configs, - const std::vector& receive_configs); - ~DegradedCall() override; - - // Implements Call. - AudioSendStream* CreateAudioSendStream( - const AudioSendStream::Config& config) override; - void DestroyAudioSendStream(AudioSendStream* send_stream) override; - - AudioReceiveStreamInterface* CreateAudioReceiveStream( - const AudioReceiveStreamInterface::Config& config) override; - void DestroyAudioReceiveStream( - AudioReceiveStreamInterface* receive_stream) override; - - VideoSendStream* CreateVideoSendStream( - VideoSendStream::Config config, - VideoEncoderConfig encoder_config) override; - VideoSendStream* CreateVideoSendStream( - VideoSendStream::Config config, - VideoEncoderConfig encoder_config, - std::unique_ptr fec_controller) override; - void DestroyVideoSendStream(VideoSendStream* send_stream) override; - - VideoReceiveStreamInterface* CreateVideoReceiveStream( - VideoReceiveStreamInterface::Config configuration) override; - void DestroyVideoReceiveStream( - VideoReceiveStreamInterface* receive_stream) override; - - FlexfecReceiveStream* CreateFlexfecReceiveStream( - const FlexfecReceiveStream::Config config) override; - void DestroyFlexfecReceiveStream( - FlexfecReceiveStream* receive_stream) override; - - void AddAdaptationResource(rtc::scoped_refptr resource) override; - - PacketReceiver* Receiver() override; - - RtpTransportControllerSendInterface* GetTransportControllerSend() override; - - Stats GetStats() const override; - - const FieldTrialsView& trials() const override; - - TaskQueueBase* network_thread() const override; - TaskQueueBase* worker_thread() const override; - - void SignalChannelNetworkState(MediaType media, NetworkState state) override; - void OnAudioTransportOverheadChanged( - int transport_overhead_per_packet) override; - void OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream, - uint32_t local_ssrc) override; - void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream, - uint32_t local_ssrc) override; - void OnLocalSsrcUpdated(FlexfecReceiveStream& stream, - uint32_t local_ssrc) override; - void OnUpdateSyncGroup(AudioReceiveStreamInterface& stream, - absl::string_view sync_group) override; - void OnSentPacket(const rtc::SentPacket& sent_packet) override; - - protected: - // Implements PacketReceiver. - void DeliverRtpPacket( - MediaType media_type, - RtpPacketReceived packet, - OnUndemuxablePacketHandler undemuxable_packet_handler) override; - void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override; - - private: - class FakeNetworkPipeOnTaskQueue { - public: - FakeNetworkPipeOnTaskQueue( - TaskQueueBase* task_queue, - rtc::scoped_refptr call_alive, - Clock* clock, - std::unique_ptr network_behavior); - - void SendRtp(rtc::ArrayView packet, - const PacketOptions& options, - Transport* transport); - void SendRtcp(rtc::ArrayView packet, Transport* transport); - - void AddActiveTransport(Transport* transport); - void RemoveActiveTransport(Transport* transport); - - private: - // Try to process packets on the fake network queue. - // Returns true if call resulted in a delayed process, false if queue empty. - bool Process(); - - Clock* const clock_; - TaskQueueBase* const task_queue_; - rtc::scoped_refptr call_alive_; - FakeNetworkPipe pipe_; - absl::optional next_process_ms_ RTC_GUARDED_BY(&task_queue_); - }; - - // For audio/video send stream, a TransportAdapter instance is used to - // intercept packets to be sent, and put them into a common FakeNetworkPipe - // in such as way that they will eventually (unless dropped) be forwarded to - // the correct Transport for that stream. - class FakeNetworkPipeTransportAdapter : public Transport { - public: - FakeNetworkPipeTransportAdapter(FakeNetworkPipeOnTaskQueue* fake_network, - Call* call, - Clock* clock, - Transport* real_transport); - ~FakeNetworkPipeTransportAdapter(); - - bool SendRtp(rtc::ArrayView packet, - const PacketOptions& options) override; - bool SendRtcp(rtc::ArrayView packet) override; - - private: - FakeNetworkPipeOnTaskQueue* const network_pipe_; - Call* const call_; - Clock* const clock_; - Transport* const real_transport_; - }; - - void SetClientBitratePreferences( - const webrtc::BitrateSettings& preferences) override; - void UpdateSendNetworkConfig(); - void UpdateReceiveNetworkConfig(); - - Clock* const clock_; - const std::unique_ptr call_; - // For cancelling tasks on the network thread when DegradedCall is destroyed - rtc::scoped_refptr call_alive_; - size_t send_config_index_; - const std::vector send_configs_; - SimulatedNetwork* send_simulated_network_; - std::unique_ptr send_pipe_; - std::map> - audio_send_transport_adapters_; - std::map> - video_send_transport_adapters_; - - size_t receive_config_index_; - const std::vector receive_configs_; - SimulatedNetwork* receive_simulated_network_; - SequenceChecker received_packet_sequence_checker_; - std::unique_ptr receive_pipe_ - RTC_GUARDED_BY(received_packet_sequence_checker_); -}; - -} // namespace webrtc - -#endif // CALL_DEGRADED_CALL_H_ diff --git a/pc/peer_connection_field_trial_tests.cc b/pc/peer_connection_field_trial_tests.cc index 3379e6723d..5d390affe7 100644 --- a/pc/peer_connection_field_trial_tests.cc +++ b/pc/peer_connection_field_trial_tests.cc @@ -41,20 +41,6 @@ namespace webrtc { -namespace { -static const int kDefaultTimeoutMs = 5000; - -bool AddIceCandidates(PeerConnectionWrapper* peer, - std::vector candidates) { - for (const auto candidate : candidates) { - if (!peer->pc()->AddIceCandidate(candidate)) { - return false; - } - } - return true; -} -} // namespace - using RTCConfiguration = PeerConnectionInterface::RTCConfiguration; class PeerConnectionFieldTrialTest : public ::testing::Test { @@ -220,59 +206,4 @@ TEST_F(PeerConnectionFieldTrialTest, MAYBE_InjectDependencyDescriptor) { EXPECT_TRUE(found2); } -// Test that the ability to emulate degraded networks works without crashing. -TEST_F(PeerConnectionFieldTrialTest, ApplyFakeNetworkConfig) { - std::unique_ptr field_trials = - std::make_unique( - "WebRTC-FakeNetworkSendConfig/link_capacity_kbps:500/" - "WebRTC-FakeNetworkReceiveConfig/loss_percent:1/"); - - CreatePCFactory(std::move(field_trials)); - - WrapperPtr caller = CreatePeerConnection(); - BitrateSettings bitrate_settings; - bitrate_settings.start_bitrate_bps = 1'000'000; - bitrate_settings.max_bitrate_bps = 1'000'000; - caller->pc()->SetBitrate(bitrate_settings); - FrameGeneratorCapturerVideoTrackSource::Config config; - auto video_track_source = - rtc::make_ref_counted( - config, clock_, /*is_screencast=*/false); - video_track_source->Start(); - caller->AddTrack(pc_factory_->CreateVideoTrack(video_track_source, "v")); - WrapperPtr callee = CreatePeerConnection(); - - ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal())); - ASSERT_TRUE( - caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal())); - - // Do the SDP negotiation, and also exchange ice candidates. - ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get())); - ASSERT_TRUE_WAIT( - caller->signaling_state() == PeerConnectionInterface::kStable, - kDefaultTimeoutMs); - ASSERT_TRUE_WAIT(caller->IsIceGatheringDone(), kDefaultTimeoutMs); - ASSERT_TRUE_WAIT(callee->IsIceGatheringDone(), kDefaultTimeoutMs); - - // Connect an ICE candidate pairs. - ASSERT_TRUE( - AddIceCandidates(callee.get(), caller->observer()->GetAllCandidates())); - ASSERT_TRUE( - AddIceCandidates(caller.get(), callee->observer()->GetAllCandidates())); - - // This means that ICE and DTLS are connected. - ASSERT_TRUE_WAIT(callee->IsIceConnected(), kDefaultTimeoutMs); - ASSERT_TRUE_WAIT(caller->IsIceConnected(), kDefaultTimeoutMs); - - // Send packets for kDefaultTimeoutMs - WAIT(false, kDefaultTimeoutMs); - - std::vector outbound_rtp_stats = - caller->GetStats()->GetStatsOfType(); - ASSERT_GE(outbound_rtp_stats.size(), 1u); - ASSERT_TRUE(outbound_rtp_stats[0]->target_bitrate.has_value()); - // Link capacity is limited to 500k, so BWE is expected to be close to 500k. - ASSERT_LE(*outbound_rtp_stats[0]->target_bitrate, 500'000 * 1.1); -} - } // namespace webrtc