From d2817d80b59656cf965ed83debfffe8c7405089b Mon Sep 17 00:00:00 2001 From: Christoffer Rodbro Date: Tue, 24 Oct 2017 16:26:49 +0200 Subject: [PATCH] Allow injection of custom network models in place of FakeNetworkPipe. Adds a constructor for DirectTransport that takes a pointer to an instance of a class derived from FakeNetworkPipe. Said class can override Process() and SendPacket(...) members thereby emulating any desired network behavior. Bug: b/67487983 Change-Id: I829fd3506124db61587af19192a14fdf62b06ca5 Reviewed-on: https://webrtc-review.googlesource.com/14620 Commit-Queue: Christoffer Rodbro Reviewed-by: Stefan Holmer Cr-Commit-Position: refs/heads/master@{#20443} --- test/direct_transport.cc | 43 +++++++++++++++++++++++++++------------- test/direct_transport.h | 6 +++++- test/fake_network_pipe.h | 9 ++++----- test/rtp_rtcp_observer.h | 8 ++++++++ 4 files changed, 46 insertions(+), 20 deletions(-) diff --git a/test/direct_transport.cc b/test/direct_transport.cc index 44f7532bf2..dddbe58909 100644 --- a/test/direct_transport.cc +++ b/test/direct_transport.cc @@ -46,13 +46,19 @@ DirectTransport::DirectTransport(SingleThreadedTaskQueueForTesting* task_queue, : send_call_(send_call), clock_(Clock::GetRealTimeClock()), task_queue_(task_queue), - fake_network_(clock_, config, std::move(demuxer)) { - RTC_DCHECK(task_queue); - if (send_call_) { - send_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); - send_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); - } - SendPackets(); + fake_network_(rtc::MakeUnique(clock_, config, + std::move(demuxer))) { + Start(); +} + +DirectTransport::DirectTransport(SingleThreadedTaskQueueForTesting* task_queue, + std::unique_ptr pipe, + Call* send_call) + : send_call_(send_call), + clock_(Clock::GetRealTimeClock()), + task_queue_(task_queue), + fake_network_(std::move(pipe)) { + Start(); } DirectTransport::~DirectTransport() { @@ -63,7 +69,7 @@ DirectTransport::~DirectTransport() { } void DirectTransport::SetConfig(const FakeNetworkPipe::Config& config) { - fake_network_.SetConfig(config); + fake_network_->SetConfig(config); } void DirectTransport::StopSending() { @@ -73,7 +79,7 @@ void DirectTransport::StopSending() { void DirectTransport::SetReceiver(PacketReceiver* receiver) { RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); - fake_network_.SetReceiver(receiver); + fake_network_->SetReceiver(receiver); } bool DirectTransport::SendRtp(const uint8_t* data, @@ -84,25 +90,34 @@ bool DirectTransport::SendRtp(const uint8_t* data, clock_->TimeInMilliseconds()); send_call_->OnSentPacket(sent_packet); } - fake_network_.SendPacket(data, length); + fake_network_->SendPacket(data, length); return true; } bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) { - fake_network_.SendPacket(data, length); + fake_network_->SendPacket(data, length); return true; } int DirectTransport::GetAverageDelayMs() { - return fake_network_.AverageDelay(); + return fake_network_->AverageDelay(); +} + +void DirectTransport::Start() { + RTC_DCHECK(task_queue_); + if (send_call_) { + send_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); + send_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); + } + SendPackets(); } void DirectTransport::SendPackets() { RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); - fake_network_.Process(); + fake_network_->Process(); - int64_t delay_ms = fake_network_.TimeUntilNextProcess(); + int64_t delay_ms = fake_network_->TimeUntilNextProcess(); next_scheduled_task_ = task_queue_->PostDelayedTask([this]() { SendPackets(); }, delay_ms); diff --git a/test/direct_transport.h b/test/direct_transport.h index 68a19683e6..85cd892ec2 100644 --- a/test/direct_transport.h +++ b/test/direct_transport.h @@ -46,6 +46,9 @@ class DirectTransport : public Transport { Call* send_call, std::unique_ptr demuxer); + DirectTransport(SingleThreadedTaskQueueForTesting* task_queue, + std::unique_ptr pipe, Call* send_call); + ~DirectTransport() override; void SetConfig(const FakeNetworkPipe::Config& config); @@ -64,6 +67,7 @@ class DirectTransport : public Transport { private: void SendPackets(); + void Start(); Call* const send_call_; Clock* const clock_; @@ -72,7 +76,7 @@ class DirectTransport : public Transport { SingleThreadedTaskQueueForTesting::TaskId next_scheduled_task_ RTC_GUARDED_BY(&sequence_checker_); - FakeNetworkPipe fake_network_; + std::unique_ptr fake_network_; rtc::SequencedTaskChecker sequence_checker_; }; diff --git a/test/fake_network_pipe.h b/test/fake_network_pipe.h index 726a3d58b3..1cfaa382f4 100644 --- a/test/fake_network_pipe.h +++ b/test/fake_network_pipe.h @@ -114,21 +114,20 @@ class FakeNetworkPipe { const FakeNetworkPipe::Config& config, std::unique_ptr demuxer, uint64_t seed); - ~FakeNetworkPipe(); - + virtual ~FakeNetworkPipe(); // Sets a new configuration. This won't affect packets already in the pipe. void SetConfig(const FakeNetworkPipe::Config& config); // Sends a new packet to the link. - void SendPacket(const uint8_t* packet, size_t packet_length); + virtual void SendPacket(const uint8_t* packet, size_t packet_length); // Must not be called in parallel with SendPacket or Process. void SetReceiver(PacketReceiver* receiver); // Processes the network queues and trigger PacketReceiver::IncomingPacket for // packets ready to be delivered. - void Process(); + virtual void Process(); int64_t TimeUntilNextProcess() const; // Get statistics. @@ -137,7 +136,7 @@ class FakeNetworkPipe { size_t dropped_packets() { return dropped_packets_; } size_t sent_packets() { return sent_packets_; } - private: + protected: Clock* const clock_; rtc::CriticalSection lock_; const std::unique_ptr demuxer_; diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h index 2164f63c0f..5163d2248e 100644 --- a/test/rtp_rtcp_observer.h +++ b/test/rtp_rtcp_observer.h @@ -105,6 +105,14 @@ class PacketTransport : public test::DirectTransport { observer_(observer), transport_type_(transport_type) {} + PacketTransport(SingleThreadedTaskQueueForTesting* task_queue, + Call* send_call, RtpRtcpObserver* observer, + TransportType transport_type, + std::unique_ptr nw_pipe) + : test::DirectTransport(task_queue, std::move(nw_pipe), send_call), + observer_(observer), + transport_type_(transport_type) {} + private: bool SendRtp(const uint8_t* packet, size_t length,