admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Propagate task queue to create test::DirectTransport by TaskQueueBase interface

Browse Source 
actual task queue implementation for these tests is intentionally unchanged for now.

while at it, change return type of created transports to unique_ptr to note passing ownership.

Bug: webrtc:10933
Change-Id: I324597b503e647c471f43511340eb9c07ba03ee8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/154743
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29335}
This commit is contained in:
Danil Chapovalov 2019-09-30 04:16:28 +02:00 committed by Commit Bot
parent 578270d9d2
commit 44db436e87
24 changed files with 133 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
audio/BUILD.gn
View File

@ -102,6 +102,7 @@ if (rtc_include_tests) {
deps = [
":audio",
"../api:simulated_network_api",
"../api/task_queue",
"../call:fake_network",
"../call:simulated_network",
"../system_wrappers",

12
audio/test/audio_bwe_integration_test.cc
View File

@ -58,10 +58,10 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
send_audio_device_ = send_audio_device;
}
test::PacketTransport* AudioBweTest::CreateSendTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> AudioBweTest::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -69,9 +69,9 @@ test::PacketTransport* AudioBweTest::CreateSendTransport(
std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
}
test::PacketTransport* AudioBweTest::CreateReceiveTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
return new test::PacketTransport(
std::unique_ptr<test::PacketTransport> AudioBweTest::CreateReceiveTransport(
TaskQueueBase* task_queue) {
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(

10
audio/test/audio_bwe_integration_test.h
View File

@ -13,9 +13,9 @@
#include <memory>
#include <string>
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "test/call_test.h"
#include "test/single_threaded_task_queue.h"
namespace webrtc {
namespace test {
@ -39,11 +39,11 @@ class AudioBweTest : public test::EndToEndTest {
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device) override;
test::PacketTransport* CreateSendTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
test::PacketTransport* CreateReceiveTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override;
void PerformTest() override;

13
audio/test/audio_end_to_end_test.cc
View File

@ -13,6 +13,7 @@
#include <algorithm>
#include <memory>
#include "api/task_queue/task_queue_base.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
#include "system_wrappers/include/sleep.h"
@ -62,10 +63,10 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated(
send_audio_device_ = send_audio_device;
}
test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> AudioEndToEndTest::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -73,9 +74,9 @@ test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
}
test::PacketTransport* AudioEndToEndTest::CreateReceiveTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
return new test::PacketTransport(
std::unique_ptr<test::PacketTransport>
AudioEndToEndTest::CreateReceiveTransport(TaskQueueBase* task_queue) {
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(

9
audio/test/audio_end_to_end_test.h
View File

@ -14,6 +14,7 @@
#include <string>
#include <vector>
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "test/call_test.h"
@ -42,11 +43,11 @@ class AudioEndToEndTest : public test::EndToEndTest {
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device) override;
test::PacketTransport* CreateSendTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
test::PacketTransport* CreateReceiveTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override;
void ModifyAudioConfigs(
AudioSendStream::Config* send_config,

27
call/call_perf_tests.cc
View File

@ -15,6 +15,7 @@
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/video_bitrate_allocation.h"
@ -376,10 +377,10 @@ void CallPerfTest::TestCaptureNtpTime(
rtp_start_timestamp_(0) {}
private:
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -387,10 +388,9 @@ void CallPerfTest::TestCaptureNtpTime(
std::make_unique<SimulatedNetwork>(net_config_)));
}
test::PacketTransport* CreateReceiveTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
return new test::PacketTransport(
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -885,26 +885,25 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
return pipe_config;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
auto network =
std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
send_simulated_network_ = network.get();
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network)));
}
test::PacketTransport* CreateReceiveTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
auto network =
std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
receive_simulated_network_ = network.get();
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),

10
call/rampup_tests.cc
View File

@ -16,6 +16,7 @@
#include "api/rtc_event_log/rtc_event_log_factory.h"
#include "api/rtc_event_log_output_file.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "call/fake_network_pipe.h"
#include "rtc_base/checks.h"
@ -116,17 +117,18 @@ void RampUpTester::OnVideoStreamsCreated(
send_stream_ = send_stream;
}
test::PacketTransport* RampUpTester::CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> RampUpTester::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
auto network = std::make_unique<SimulatedNetwork>(forward_transport_config_);
send_simulated_network_ = network.get();
send_transport_ = new test::PacketTransport(
auto send_transport = std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
std::move(network)));
return send_transport_;
send_transport_ = send_transport.get();
return send_transport;
}
size_t RampUpTester::GetNumVideoStreams() const {

6
call/rampup_tests.h
View File

@ -12,11 +12,13 @@
#define CALL_RAMPUP_TESTS_H_
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "call/call.h"
#include "call/simulated_network.h"
@ -87,8 +89,8 @@ class RampUpTester : public test::EndToEndTest {
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,

19
test/call_test.cc
View File

@ -16,6 +16,7 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder_config.h"
#include "call/fake_network_pipe.h"
@ -133,9 +134,9 @@ void CallTest::RunBaseTest(BaseTest* test) {
CreateReceiverCall(recv_config);
}
test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
receive_transport_.reset(test->CreateReceiveTransport(&task_queue_));
send_transport_.reset(
test->CreateSendTransport(&task_queue_, sender_call_.get()));
receive_transport_ = test->CreateReceiveTransport(&task_queue_);
send_transport_ =
test->CreateSendTransport(&task_queue_, sender_call_.get());
if (test->ShouldCreateReceivers()) {
send_transport_->SetReceiver(receiver_call_->Receiver());
@ -776,10 +777,10 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
test::PacketTransport* BaseTest::CreateSendTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<PacketTransport> BaseTest::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return new PacketTransport(
return std::make_unique<PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -787,9 +788,9 @@ test::PacketTransport* BaseTest::CreateSendTransport(
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())));
}
test::PacketTransport* BaseTest::CreateReceiveTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
return new PacketTransport(
std::unique_ptr<PacketTransport> BaseTest::CreateReceiveTransport(
TaskQueueBase* task_queue) {
return std::make_unique<PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(

9
test/call_test.h
View File

@ -17,6 +17,7 @@
#include "absl/types/optional.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/video/function_video_decoder_factory.h"
#include "api/test/video/function_video_encoder_factory.h"
@ -260,11 +261,11 @@ class BaseTest : public RtpRtcpObserver {
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
virtual test::PacketTransport* CreateSendTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
virtual std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call);
virtual test::PacketTransport* CreateReceiveTransport(
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
virtual std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue);
virtual void ModifyVideoConfigs(
VideoSendStream::Config* send_config,

2
test/rtp_rtcp_observer.h
View File

@ -85,7 +85,7 @@ class PacketTransport : public test::DirectTransport {
public:
enum TransportType { kReceiver, kSender };
PacketTransport(DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
PacketTransport(TaskQueueBase* task_queue,
Call* send_call,
RtpRtcpObserver* observer,
TransportType transport_type,

1
video/BUILD.gn
View File

@ -570,6 +570,7 @@ if (rtc_include_tests) {
"../api:simulated_network_api",
"../api/crypto:options",
"../api/rtc_event_log",
"../api/task_queue",
"../api/task_queue:default_task_queue_factory",
"../api/test/video:function_video_factory",
"../api/units:data_rate",

11
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -10,6 +10,7 @@
#include <memory>
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/video_bitrate_allocation.h"
@ -170,16 +171,16 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
~BweObserver() {}
test::PacketTransport* CreateReceiveTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
receive_transport_ = new test::PacketTransport(
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
auto receive_transport = std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
return receive_transport_;
receive_transport_ = receive_transport.get();
return receive_transport;
}
void ModifySenderBitrateConfig(

7
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -18,6 +18,7 @@
#include "absl/types/optional.h"
#include "api/rtp_headers.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/video_codecs/sdp_video_format.h"
#include "api/video_codecs/video_encoder_config.h"
@ -158,13 +159,13 @@ class RtcpXrObserver : public test::EndToEndTest {
return enable_zero_target_bitrate_ ? 2 : 1;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
auto network =
std::make_unique<SimulatedNetwork>(forward_transport_config_);
send_simulated_network_ = network.get();
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),

13
video/end_to_end_tests/fec_tests.cc
View File

@ -10,6 +10,7 @@
#include <memory>
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "call/fake_network_pipe.h"
@ -246,14 +247,14 @@ class FlexfecRenderObserver : public test::EndToEndTest,
return SEND_PACKET;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
const int kNetworkDelayMs = 100;
BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
test::CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -431,15 +432,15 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
return SEND_PACKET;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
const int kNetworkDelayMs = 50;
BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(

20
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -17,6 +17,7 @@
#include "absl/memory/memory.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
@ -66,10 +67,9 @@ void MultiStreamTester::RunTest() {
task_queue_->SendTask([&]() {
sender_call = absl::WrapUnique(Call::Create(config));
receiver_call = absl::WrapUnique(Call::Create(config));
sender_transport =
absl::WrapUnique(CreateSendTransport(task_queue_, sender_call.get()));
receiver_transport = absl::WrapUnique(
CreateReceiveTransport(task_queue_, receiver_call.get()));
sender_transport = CreateSendTransport(task_queue_, sender_call.get());
receiver_transport =
CreateReceiveTransport(task_queue_, receiver_call.get());
sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver());
@ -151,10 +151,10 @@ void MultiStreamTester::UpdateReceiveConfig(
size_t stream_index,
VideoReceiveStream::Config* receive_config) {}
test::DirectTransport* MultiStreamTester::CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) {
return new test::DirectTransport(
return std::make_unique<test::DirectTransport>(
task_queue,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
@ -162,10 +162,10 @@ test::DirectTransport* MultiStreamTester::CreateSendTransport(
sender_call, payload_type_map_);
}
test::DirectTransport* MultiStreamTester::CreateReceiveTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::DirectTransport>
MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue,
Call* receiver_call) {
return new test::DirectTransport(
return std::make_unique<test::DirectTransport>(
task_queue,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),

10
video/end_to_end_tests/multi_stream_tester.h
View File

@ -12,7 +12,9 @@
#define VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_
#include <map>
#include <memory>
#include "api/task_queue/task_queue_base.h"
#include "call/call.h"
#include "test/direct_transport.h"
#include "test/frame_generator_capturer.h"
@ -51,11 +53,11 @@ class MultiStreamTester {
test::FrameGeneratorCapturer** frame_generator);
virtual void UpdateReceiveConfig(size_t stream_index,
VideoReceiveStream::Config* receive_config);
virtual test::DirectTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
virtual std::unique_ptr<test::DirectTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call);
virtual test::DirectTransport* CreateReceiveTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(
TaskQueueBase* task_queue,
Call* receiver_call);
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;

7
video/end_to_end_tests/probing_tests.cc
View File

@ -10,6 +10,7 @@
#include <memory>
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
@ -220,13 +221,13 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
send_stream_ = send_stream;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
auto network =
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig());
send_simulated_network_ = network.get();
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
CallTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),

10
video/end_to_end_tests/retransmission_tests.cc
View File

@ -11,6 +11,7 @@
#include <memory>
#include "absl/algorithm/container.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "call/fake_network_pipe.h"
@ -137,16 +138,15 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
size_t GetNumVideoStreams() const override { return 0; }
size_t GetNumAudioStreams() const override { return 1; }
test::PacketTransport* CreateReceiveTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
test::PacketTransport* receive_transport = new test::PacketTransport(
std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
TaskQueueBase* task_queue) override {
auto receive_transport = std::make_unique<test::PacketTransport>(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())));
receive_transport_ = receive_transport;
receive_transport_ = receive_transport.get();
return receive_transport;
}

13
video/end_to_end_tests/stats_tests.cc
View File

@ -11,6 +11,7 @@
#include <memory>
#include "absl/algorithm/container.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "call/fake_network_pipe.h"
@ -232,12 +233,12 @@ TEST_F(StatsEndToEndTest, GetStats) {
return true;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig network_config;
network_config.loss_percent = 5;
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -530,9 +531,9 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
CreateSenderCall(send_config);
CreateReceiverCall(recv_config);
receive_transport_.reset(test.CreateReceiveTransport(&task_queue_));
send_transport_.reset(
test.CreateSendTransport(&task_queue_, sender_call_.get()));
receive_transport_ = test.CreateReceiveTransport(&task_queue_);
send_transport_ =
test.CreateSendTransport(&task_queue_, sender_call_.get());
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_->SetReceiver(sender_call_->Receiver());

12
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -10,6 +10,7 @@
#include <memory>
#include "api/task_queue/task_queue_base.h"
#include "call/call.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
@ -39,7 +40,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class RtpExtensionHeaderObserver : public test::DirectTransport {
public:
RtpExtensionHeaderObserver(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
TaskQueueBase* task_queue,
Call* sender_call,
const uint32_t& first_media_ssrc,
const std::map<uint32_t, uint32_t>& ssrc_map,
@ -217,18 +218,19 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
receive_config->renderer = &fake_renderer_;
}
test::DirectTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::DirectTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
std::map<uint8_t, MediaType> payload_type_map =
MultiStreamTester::payload_type_map_;
RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) ==
payload_type_map.end());
payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO;
observer_ = new RtpExtensionHeaderObserver(
auto observer = std::make_unique<RtpExtensionHeaderObserver>(
task_queue, sender_call, first_media_ssrc_, rtx_to_media_ssrcs_,
payload_type_map);
return observer_;
observer_ = observer.get();
return observer;
}
private:

1
video/video_quality_test.cc
View File

@ -21,6 +21,7 @@
#include "api/fec_controller_override.h"
#include "api/rtc_event_log_output_file.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/transport/media/media_transport_config.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video_codecs/video_encoder.h"

1
video/video_quality_test.h
View File

@ -17,6 +17,7 @@
#include "api/fec_controller.h"
#include "api/rtc_event_log/rtc_event_log_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/video_quality_test_fixture.h"
#include "api/video/video_bitrate_allocator_factory.h"

19
video/video_send_stream_tests.cc
View File

@ -13,6 +13,7 @@
#include "absl/algorithm/container.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/simulated_network.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/encoded_image.h"
@ -554,8 +555,8 @@ class UlpfecObserver : public test::EndToEndTest {
return SEND_PACKET;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
@ -563,7 +564,7 @@ class UlpfecObserver : public test::EndToEndTest {
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 5;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
VideoSendStreamTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -751,8 +752,8 @@ class FlexfecObserver : public test::EndToEndTest {
return SEND_PACKET;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Therefore we need some network delay.
@ -760,7 +761,7 @@ class FlexfecObserver : public test::EndToEndTest {
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 5;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
VideoSendStreamTest::payload_type_map_,
std::make_unique<FakeNetworkPipe>(
@ -1531,15 +1532,15 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
return SEND_PACKET;
}
test::PacketTransport* CreateSendTransport(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override {
const int kNetworkDelayMs = 50;
BuiltInNetworkBehaviorConfig config;
config.loss_percent = 10;
config.link_capacity_kbps = kCapacityKbps;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(
return std::make_unique<test::PacketTransport>(
task_queue, sender_call, this, test::PacketTransport::kSender,
payload_type_map_,
std::make_unique<FakeNetworkPipe>(