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

Deprecate SingleThreadedTaskQueueForTesting class.

Browse Source 
This class doesn't strictly follow rtc::TaskQueue semantics,
which makes it surprising and hard to use correctly.
Please use TaskQueueForTest instead.

This CL follows usual deprecation process:

1/ Rename.
% for i in `git ls-files` ; sed -i "s:SingleThreadedTaskQueueForTesting:DEPRECATED_SingleThreadedTaskQueueForTesting:" $i

2/ Annotate old name for downstream users and accidental new uses.

Bug: webrtc:10933
Change-Id: I80b4ee5a48df1f63f63a43ed0efdb50eb7fb156a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/150788
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Tommi <tommi@webrtc.org>
Commit-Queue: Yves Gerey <yvesg@google.com>
Cr-Commit-Position: refs/heads/master@{#29045}
This commit is contained in:
Yves Gerey 2019-08-29 11:50:23 +02:00 committed by Commit Bot
parent f2773b5464
commit 6516f76f9b
35 changed files with 208 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
audio/test/audio_bwe_integration_test.cc
View File

@ -58,7 +58,7 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
}
test::PacketTransport* AudioBweTest::CreateSendTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) {
return new test::PacketTransport(
task_queue, sender_call, this, test::PacketTransport::kSender,
@ -69,7 +69,7 @@ test::PacketTransport* AudioBweTest::CreateSendTransport(
}
test::PacketTransport* AudioBweTest::CreateReceiveTransport(
SingleThreadedTaskQueueForTesting* task_queue) {
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
return new test::PacketTransport(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,

4
audio/test/audio_bwe_integration_test.h
View File

@ -40,10 +40,10 @@ class AudioBweTest : public test::EndToEndTest {
TestAudioDeviceModule* recv_audio_device) override;
test::PacketTransport* CreateSendTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override;
test::PacketTransport* CreateReceiveTransport(
SingleThreadedTaskQueueForTesting* task_queue) override;
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
void PerformTest() override;

4
audio/test/audio_end_to_end_test.cc
View File

@ -63,7 +63,7 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated(
}
test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) {
return new test::PacketTransport(
task_queue, sender_call, this, test::PacketTransport::kSender,
@ -74,7 +74,7 @@ test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
}
test::PacketTransport* AudioEndToEndTest::CreateReceiveTransport(
SingleThreadedTaskQueueForTesting* task_queue) {
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
return new test::PacketTransport(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
test::CallTest::payload_type_map_,

4
audio/test/audio_end_to_end_test.h
View File

@ -43,10 +43,10 @@ class AudioEndToEndTest : public test::EndToEndTest {
TestAudioDeviceModule* recv_audio_device) override;
test::PacketTransport* CreateSendTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override;
test::PacketTransport* CreateReceiveTransport(
SingleThreadedTaskQueueForTesting* task_queue) override;
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
void ModifyAudioConfigs(
AudioSendStream::Config* send_config,

14
call/call_perf_tests.cc
View File

@ -378,7 +378,7 @@ void CallPerfTest::TestCaptureNtpTime(
private:
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
return new test::PacketTransport(
task_queue, sender_call, this, test::PacketTransport::kSender,
@ -389,7 +389,8 @@ void CallPerfTest::TestCaptureNtpTime(
}
test::PacketTransport* CreateReceiveTransport(
test::SingleThreadedTaskQueueForTesting* task_queue) override {
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
return new test::PacketTransport(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
@ -868,7 +869,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
int min_bwe,
int start_bwe,
int max_bwe,
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(),
test_bitrate_from_(test_bitrate_from),
test_bitrate_to_(test_bitrate_to),
@ -886,7 +887,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
auto network =
absl::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
@ -899,7 +900,8 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
}
test::PacketTransport* CreateReceiveTransport(
test::SingleThreadedTaskQueueForTesting* task_queue) override {
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
auto network =
absl::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
receive_simulated_network_ = network.get();
@ -982,7 +984,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
SimulatedNetwork* send_simulated_network_;
SimulatedNetwork* receive_simulated_network_;
Call* sender_call_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
} test(test_bitrate_from, test_bitrate_to, test_bitrate_step, min_bwe,
start_bwe, max_bwe, &task_queue_);

31
call/rampup_tests.cc
View File

@ -53,16 +53,17 @@ std::vector<uint32_t> GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) {
}
} // namespace
RampUpTester::RampUpTester(size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
unsigned int start_bitrate_bps,
int64_t min_run_time_ms,
const std::string& extension_type,
bool rtx,
bool red,
bool report_perf_stats,
test::SingleThreadedTaskQueueForTesting* task_queue)
RampUpTester::RampUpTester(
size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
unsigned int start_bitrate_bps,
int64_t min_run_time_ms,
const std::string& extension_type,
bool rtx,
bool red,
bool report_perf_stats,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(test::CallTest::kLongTimeoutMs),
clock_(Clock::GetRealTimeClock()),
num_video_streams_(num_video_streams),
@ -94,7 +95,8 @@ RampUpTester::~RampUpTester() {
// Special case for WebRTC-QuickPerfTest/Enabled/
task_queue_->SendTask([this]() {
if (pending_task_ !=
static_cast<test::SingleThreadedTaskQueueForTesting::TaskId>(-1)) {
static_cast<test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId>(
-1)) {
task_queue_->CancelTask(pending_task_);
pending_task_ = -1;
}
@ -116,7 +118,7 @@ void RampUpTester::OnVideoStreamsCreated(
}
test::PacketTransport* RampUpTester::CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) {
auto network = absl::make_unique<SimulatedNetwork>(forward_transport_config_);
send_simulated_network_ = network.get();
@ -380,7 +382,8 @@ void RampUpTester::TriggerTestDone() {
// Corner case for field_trials=WebRTC-QuickPerfTest/Enabled/
task_queue_->SendTask([this]() {
if (pending_task_ !=
static_cast<test::SingleThreadedTaskQueueForTesting::TaskId>(-1)) {
static_cast<test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId>(
-1)) {
task_queue_->CancelTask(pending_task_);
pending_task_ = -1;
}
@ -453,7 +456,7 @@ RampUpDownUpTester::RampUpDownUpTester(
bool red,
const std::vector<int>& loss_rates,
bool report_perf_stats,
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: RampUpTester(num_video_streams,
num_audio_streams,
num_flexfec_streams,

29
call/rampup_tests.h
View File

@ -43,7 +43,7 @@ class RampUpTester : public test::EndToEndTest {
bool rtx,
bool red,
bool report_perf_stats,
test::SingleThreadedTaskQueueForTesting* task_queue);
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
~RampUpTester() override;
size_t GetNumVideoStreams() const override;
@ -88,7 +88,7 @@ class RampUpTester : public test::EndToEndTest {
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override;
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
@ -127,22 +127,23 @@ class RampUpTester : public test::EndToEndTest {
// Must be called from the |task_queue_|.
int64_t GetIntervalForNextPoll();
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::SingleThreadedTaskQueueForTesting::TaskId pending_task_ = -1;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId pending_task_ = -1;
};
class RampUpDownUpTester : public RampUpTester {
public:
RampUpDownUpTester(size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
unsigned int start_bitrate_bps,
const std::string& extension_type,
bool rtx,
bool red,
const std::vector<int>& loss_rates,
bool report_perf_stats,
test::SingleThreadedTaskQueueForTesting* task_queue);
RampUpDownUpTester(
size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
unsigned int start_bitrate_bps,
const std::string& extension_type,
bool rtx,
bool red,
const std::vector<int>& loss_rates,
bool report_perf_stats,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
~RampUpDownUpTester() override;
protected:

1
test/BUILD.gn
View File

@ -626,6 +626,7 @@ rtc_source_set("single_threaded_task_queue") {
]
deps = [
"../rtc_base:checks",
"../rtc_base:deprecation",
"../rtc_base:rtc_base_approved",
"//third_party/abseil-cpp/absl/memory",
]

4
test/call_test.cc
View File

@ -778,7 +778,7 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
test::PacketTransport* BaseTest::CreateSendTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) {
return new PacketTransport(
task_queue, sender_call, this, test::PacketTransport::kSender,
@ -789,7 +789,7 @@ test::PacketTransport* BaseTest::CreateSendTransport(
}
test::PacketTransport* BaseTest::CreateReceiveTransport(
SingleThreadedTaskQueueForTesting* task_queue) {
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
return new PacketTransport(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
CallTest::payload_type_map_,

6
test/call_test.h
View File

@ -220,7 +220,7 @@ class CallTest : public ::testing::Test {
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
test::FakeVideoRenderer fake_renderer_;
SingleThreadedTaskQueueForTesting task_queue_;
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue_;
private:
absl::optional<RtpExtension> GetRtpExtensionByUri(
@ -261,10 +261,10 @@ class BaseTest : public RtpRtcpObserver {
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
virtual test::PacketTransport* CreateSendTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call);
virtual test::PacketTransport* CreateReceiveTransport(
SingleThreadedTaskQueueForTesting* task_queue);
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
virtual void ModifyVideoConfigs(
VideoSendStream::Config* send_config,

2
test/direct_transport.cc
View File

@ -37,7 +37,7 @@ MediaType Demuxer::GetMediaType(const uint8_t* packet_data,
}
DirectTransport::DirectTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
const std::map<uint8_t, MediaType>& payload_type_map)

8
test/direct_transport.h
View File

@ -39,7 +39,7 @@ class Demuxer {
// same task-queue - the one that's passed in via the constructor.
class DirectTransport : public Transport {
public:
DirectTransport(SingleThreadedTaskQueueForTesting* task_queue,
DirectTransport(DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
const std::map<uint8_t, MediaType>& payload_type_map);
@ -65,11 +65,11 @@ class DirectTransport : public Transport {
Call* const send_call_;
SingleThreadedTaskQueueForTesting* const task_queue_;
DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
rtc::CriticalSection process_lock_;
absl::optional<SingleThreadedTaskQueueForTesting::TaskId> next_process_task_
RTC_GUARDED_BY(&process_lock_);
absl::optional<DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId>
next_process_task_ RTC_GUARDED_BY(&process_lock_);
const Demuxer demuxer_;
const std::unique_ptr<SimulatedPacketReceiverInterface> fake_network_;

4
test/layer_filtering_transport.cc
View File

@ -30,7 +30,7 @@ namespace webrtc {
namespace test {
LayerFilteringTransport::LayerFilteringTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
uint8_t vp8_video_payload_type,
@ -50,7 +50,7 @@ LayerFilteringTransport::LayerFilteringTransport(
ssrc_to_filter_max_(ssrc_to_filter_max) {}
LayerFilteringTransport::LayerFilteringTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
uint8_t vp8_video_payload_type,

4
test/layer_filtering_transport.h
View File

@ -30,7 +30,7 @@ namespace test {
class LayerFilteringTransport : public test::DirectTransport {
public:
LayerFilteringTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
uint8_t vp8_video_payload_type,
@ -41,7 +41,7 @@ class LayerFilteringTransport : public test::DirectTransport {
uint32_t ssrc_to_filter_min,
uint32_t ssrc_to_filter_max);
LayerFilteringTransport(
SingleThreadedTaskQueueForTesting* task_queue,
DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
Call* send_call,
uint8_t vp8_video_payload_type,

4
test/rtp_rtcp_observer.h
View File

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

2
test/run_loop.cc
View File

@ -14,7 +14,7 @@
namespace webrtc {
namespace test {
void PressEnterToContinue(SingleThreadedTaskQueueForTesting&) {
void PressEnterToContinue(DEPRECATED_SingleThreadedTaskQueueForTesting&) {
puts(">> Press ENTER to continue...");
while (getc(stdin) != '\n' && !feof(stdin))
;

3
test/run_loop.h
View File

@ -16,7 +16,8 @@ namespace webrtc {
namespace test {
// Blocks until the user presses enter.
void PressEnterToContinue(SingleThreadedTaskQueueForTesting& task_queue);
void PressEnterToContinue(
DEPRECATED_SingleThreadedTaskQueueForTesting& task_queue);
} // namespace test
} // namespace webrtc

45
test/single_threaded_task_queue.cc
View File

@ -20,34 +20,37 @@
namespace webrtc {
namespace test {
SingleThreadedTaskQueueForTesting::QueuedTask::QueuedTask(
SingleThreadedTaskQueueForTesting::TaskId task_id,
DEPRECATED_SingleThreadedTaskQueueForTesting::QueuedTask::QueuedTask(
DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId task_id,
int64_t earliest_execution_time,
SingleThreadedTaskQueueForTesting::Task task)
DEPRECATED_SingleThreadedTaskQueueForTesting::Task task)
: task_id(task_id),
earliest_execution_time(earliest_execution_time),
task(task) {}
SingleThreadedTaskQueueForTesting::QueuedTask::~QueuedTask() = default;
DEPRECATED_SingleThreadedTaskQueueForTesting::QueuedTask::~QueuedTask() =
default;
SingleThreadedTaskQueueForTesting::SingleThreadedTaskQueueForTesting(
const char* name)
DEPRECATED_SingleThreadedTaskQueueForTesting::
DEPRECATED_SingleThreadedTaskQueueForTesting(const char* name)
: thread_(Run, this, name), running_(true), next_task_id_(0) {
thread_.Start();
}
SingleThreadedTaskQueueForTesting::~SingleThreadedTaskQueueForTesting() {
DEPRECATED_SingleThreadedTaskQueueForTesting::
~DEPRECATED_SingleThreadedTaskQueueForTesting() {
Stop();
}
SingleThreadedTaskQueueForTesting::TaskId
SingleThreadedTaskQueueForTesting::PostTask(Task task) {
DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId
DEPRECATED_SingleThreadedTaskQueueForTesting::PostTask(Task task) {
return PostDelayedTask(task, 0);
}
SingleThreadedTaskQueueForTesting::TaskId
SingleThreadedTaskQueueForTesting::PostDelayedTask(Task task,
int64_t delay_ms) {
DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId
DEPRECATED_SingleThreadedTaskQueueForTesting::PostDelayedTask(
Task task,
int64_t delay_ms) {
int64_t earliest_exec_time = rtc::TimeAfter(delay_ms);
rtc::CritScope lock(&cs_);
@ -75,7 +78,7 @@ SingleThreadedTaskQueueForTesting::PostDelayedTask(Task task,
return id;
}
void SingleThreadedTaskQueueForTesting::SendTask(Task task) {
void DEPRECATED_SingleThreadedTaskQueueForTesting::SendTask(Task task) {
RTC_DCHECK(!IsCurrent());
rtc::Event done;
if (PostTask([&task, &done]() {
@ -88,7 +91,7 @@ void SingleThreadedTaskQueueForTesting::SendTask(Task task) {
RTC_CHECK(done.Wait(30000, 10000));
}
bool SingleThreadedTaskQueueForTesting::CancelTask(TaskId task_id) {
bool DEPRECATED_SingleThreadedTaskQueueForTesting::CancelTask(TaskId task_id) {
rtc::CritScope lock(&cs_);
for (auto it = tasks_.begin(); it != tasks_.end(); it++) {
if ((*it)->task_id == task_id) {
@ -99,23 +102,23 @@ bool SingleThreadedTaskQueueForTesting::CancelTask(TaskId task_id) {
return false;
}
bool SingleThreadedTaskQueueForTesting::IsCurrent() {
bool DEPRECATED_SingleThreadedTaskQueueForTesting::IsCurrent() {
return rtc::IsThreadRefEqual(thread_.GetThreadRef(), rtc::CurrentThreadRef());
}
bool SingleThreadedTaskQueueForTesting::IsRunning() {
bool DEPRECATED_SingleThreadedTaskQueueForTesting::IsRunning() {
RTC_DCHECK_RUN_ON(&owner_thread_checker_);
// We could check the |running_| flag here, but this is equivalent for the
// purposes of this function.
return thread_.IsRunning();
}
bool SingleThreadedTaskQueueForTesting::HasPendingTasks() const {
bool DEPRECATED_SingleThreadedTaskQueueForTesting::HasPendingTasks() const {
rtc::CritScope lock(&cs_);
return !tasks_.empty();
}
void SingleThreadedTaskQueueForTesting::Stop() {
void DEPRECATED_SingleThreadedTaskQueueForTesting::Stop() {
RTC_DCHECK_RUN_ON(&owner_thread_checker_);
if (!thread_.IsRunning())
return;
@ -129,11 +132,11 @@ void SingleThreadedTaskQueueForTesting::Stop() {
thread_.Stop();
}
void SingleThreadedTaskQueueForTesting::Run(void* obj) {
static_cast<SingleThreadedTaskQueueForTesting*>(obj)->RunLoop();
void DEPRECATED_SingleThreadedTaskQueueForTesting::Run(void* obj) {
static_cast<DEPRECATED_SingleThreadedTaskQueueForTesting*>(obj)->RunLoop();
}
void SingleThreadedTaskQueueForTesting::RunLoop() {
void DEPRECATED_SingleThreadedTaskQueueForTesting::RunLoop() {
while (true) {
std::unique_ptr<QueuedTask> queued_task;

15
test/single_threaded_task_queue.h
View File

@ -15,6 +15,7 @@
#include <memory>
#include "rtc_base/critical_section.h"
#include "rtc_base/deprecation.h"
#include "rtc_base/event.h"
#include "rtc_base/platform_thread.h"
#include "rtc_base/thread_checker.h"
@ -22,20 +23,24 @@
namespace webrtc {
namespace test {
// DEPRECATED. This class doesn't striclty follow rtc::TaskQueue semantics,
// which makes it surprising and hard to use correctly.
// Please use TaskQueueForTest instead.
// This class gives capabilities similar to rtc::TaskQueue, but ensures
// everything happens on the same thread. This is intended to make the
// threading model of unit-tests (specifically end-to-end tests) more closely
// resemble that of real WebRTC, thereby allowing us to replace some critical
// sections by thread-checkers.
// This task is NOT tuned for performance, but rather for simplicity.
class SingleThreadedTaskQueueForTesting {
class DEPRECATED_SingleThreadedTaskQueueForTesting {
public:
using Task = std::function<void()>;
using TaskId = size_t;
constexpr static TaskId kInvalidTaskId = static_cast<TaskId>(-1);
explicit SingleThreadedTaskQueueForTesting(const char* name);
~SingleThreadedTaskQueueForTesting();
explicit DEPRECATED_SingleThreadedTaskQueueForTesting(const char* name);
~DEPRECATED_SingleThreadedTaskQueueForTesting();
// Sends one task to the task-queue, and returns a handle by which the
// task can be cancelled.
@ -102,6 +107,10 @@ class SingleThreadedTaskQueueForTesting {
rtc::Event wake_up_;
};
// Warn if new usage.
typedef DEPRECATED_SingleThreadedTaskQueueForTesting RTC_DEPRECATED
SingleThreadedTaskQueueForTesting;
} // namespace test
} // namespace webrtc

62
test/single_threaded_task_queue_unittest.cc
View File

@ -23,18 +23,19 @@ namespace test {
namespace {
using TaskId = SingleThreadedTaskQueueForTesting::TaskId;
using TaskId = DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId;
// Test should not rely on the object under test not being faulty. If the task
// queue ever blocks forever, we want the tests to fail, rather than hang.
constexpr int kMaxWaitTimeMs = 10000;
TEST(SingleThreadedTaskQueueForTestingTest, SanityConstructionDestruction) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
SanityConstructionDestruction) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
}
TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
rtc::Event done;
@ -48,9 +49,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
EXPECT_TRUE(executed.load());
}
TEST(SingleThreadedTaskQueueForTestingTest,
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
PostMultipleTasksFromSameExternalThread) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
constexpr size_t kCount = 3;
std::atomic<bool> executed[kCount];
@ -91,8 +92,9 @@ TEST(SingleThreadedTaskQueueForTestingTest,
}
}
TEST(SingleThreadedTaskQueueForTestingTest, PostToTaskQueueFromOwnThread) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
PostToTaskQueueFromOwnThread) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
rtc::Event done;
@ -112,8 +114,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, PostToTaskQueueFromOwnThread) {
EXPECT_TRUE(executed.load());
}
TEST(SingleThreadedTaskQueueForTestingTest, TasksExecutedInSequence) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
TasksExecutedInSequence) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
// The first task would perform:
// accumulator = 10 * accumulator + i
@ -146,8 +149,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, TasksExecutedInSequence) {
EXPECT_EQ(accumulator, expected_value);
}
TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedDelayedTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
ExecutesPostedDelayedTask) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
rtc::Event done;
@ -166,8 +170,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedDelayedTask) {
EXPECT_TRUE(executed.load());
}
TEST(SingleThreadedTaskQueueForTestingTest, DoesNotExecuteDelayedTaskTooSoon) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
DoesNotExecuteDelayedTaskTooSoon) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
@ -182,9 +187,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, DoesNotExecuteDelayedTaskTooSoon) {
EXPECT_FALSE(executed.load());
}
TEST(SingleThreadedTaskQueueForTestingTest,
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
TaskWithLesserDelayPostedAfterFirstDelayedTaskExectuedBeforeFirst) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> earlier_executed(false);
constexpr int64_t earlier_delay_ms = 500;
@ -216,9 +221,9 @@ TEST(SingleThreadedTaskQueueForTestingTest,
ASSERT_TRUE(later_executed);
}
TEST(SingleThreadedTaskQueueForTestingTest,
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
TaskWithGreaterDelayPostedAfterFirstDelayedTaskExectuedAfterFirst) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> earlier_executed(false);
constexpr int64_t earlier_delay_ms = 500;
@ -250,8 +255,9 @@ TEST(SingleThreadedTaskQueueForTestingTest,
ASSERT_TRUE(later_executed);
}
TEST(SingleThreadedTaskQueueForTestingTest, ExternalThreadCancelsTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
ExternalThreadCancelsTask) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
rtc::Event done;
@ -276,8 +282,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExternalThreadCancelsTask) {
// In this test, we'll set off a chain where the first task cancels the second
// task, then a third task runs (showing that we really cancelled the task,
// rather than just halted the task-queue).
TEST(SingleThreadedTaskQueueForTestingTest, InternalThreadCancelsTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
InternalThreadCancelsTask) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
rtc::Event done;
@ -308,8 +315,8 @@ TEST(SingleThreadedTaskQueueForTestingTest, InternalThreadCancelsTask) {
ASSERT_TRUE(done.Wait(kMaxWaitTimeMs));
}
TEST(SingleThreadedTaskQueueForTestingTest, SendTask) {
SingleThreadedTaskQueueForTesting task_queue("task_queue");
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest, SendTask) {
DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
std::atomic<bool> executed(false);
@ -324,10 +331,11 @@ TEST(SingleThreadedTaskQueueForTestingTest, SendTask) {
EXPECT_TRUE(executed);
}
TEST(SingleThreadedTaskQueueForTestingTest,
TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
DestructTaskQueueWhileTasksPending) {
auto task_queue =
absl::make_unique<SingleThreadedTaskQueueForTesting>("task_queue");
absl::make_unique<DEPRECATED_SingleThreadedTaskQueueForTesting>(
"task_queue");
std::atomic<size_t> counter(0);

3
test/win/run_loop_win.cc
View File

@ -17,7 +17,8 @@
namespace webrtc {
namespace test {
void PressEnterToContinue(SingleThreadedTaskQueueForTesting& task_queue) {
void PressEnterToContinue(
DEPRECATED_SingleThreadedTaskQueueForTesting& task_queue) {
puts(">> Press ENTER to continue...");
while (!_kbhit() || _getch() != '\r') {

22
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -79,8 +79,9 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class BandwidthStatsTest : public test::EndToEndTest {
public:
BandwidthStatsTest(bool send_side_bwe,
test::SingleThreadedTaskQueueForTesting* task_queue)
BandwidthStatsTest(
bool send_side_bwe,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
sender_call_(nullptr),
receiver_call_(nullptr),
@ -135,7 +136,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
Call* receiver_call_;
bool has_seen_pacer_delay_;
const bool send_side_bwe_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
};
TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) {
@ -156,7 +157,8 @@ TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest {
public:
explicit BweObserver(test::SingleThreadedTaskQueueForTesting* task_queue)
explicit BweObserver(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
sender_call_(nullptr),
clock_(Clock::GetRealTimeClock()),
@ -170,7 +172,8 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
~BweObserver() {}
test::PacketTransport* CreateReceiveTransport(
test::SingleThreadedTaskQueueForTesting* task_queue) override {
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
receive_transport_ = new test::PacketTransport(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
@ -267,8 +270,9 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
test::PacketTransport* receive_transport_;
TestState state_;
RateLimiter retransmission_rate_limiter_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::SingleThreadedTaskQueueForTesting::TaskId pending_task_ = ~0;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId pending_task_ =
~0;
} test(&task_queue_);
RunBaseTest(&test);
@ -285,7 +289,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
public test::FakeEncoder {
public:
explicit EncoderRateStatsTest(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
@ -360,7 +364,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
}
private:
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
rtc::CriticalSection crit_;
VideoSendStream* send_stream_;
test::VideoEncoderProxyFactory encoder_factory_;

2
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -160,7 +160,7 @@ class RtcpXrObserver : public test::EndToEndTest {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) {
auto network =
absl::make_unique<SimulatedNetwork>(forward_transport_config_);

4
video/end_to_end_tests/fec_tests.cc
View File

@ -246,7 +246,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
const int kNetworkDelayMs = 100;
@ -431,7 +431,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.

6
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -30,7 +30,7 @@
namespace webrtc {
MultiStreamTester::MultiStreamTester(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: task_queue_(task_queue) {
// TODO(sprang): Cleanup when msvc supports explicit initializers for array.
codec_settings[0] = {1, 640, 480};
@ -152,7 +152,7 @@ void MultiStreamTester::UpdateReceiveConfig(
VideoReceiveStream::Config* receive_config) {}
test::DirectTransport* MultiStreamTester::CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) {
return new test::DirectTransport(
task_queue,
@ -163,7 +163,7 @@ test::DirectTransport* MultiStreamTester::CreateSendTransport(
}
test::DirectTransport* MultiStreamTester::CreateReceiveTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* receiver_call) {
return new test::DirectTransport(
task_queue,

8
video/end_to_end_tests/multi_stream_tester.h
View File

@ -34,7 +34,7 @@ class MultiStreamTester {
} codec_settings[kNumStreams];
explicit MultiStreamTester(
test::SingleThreadedTaskQueueForTesting* task_queue);
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
virtual ~MultiStreamTester();
@ -52,13 +52,13 @@ class MultiStreamTester {
virtual void UpdateReceiveConfig(size_t stream_index,
VideoReceiveStream::Config* receive_config);
virtual test::DirectTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call);
virtual test::DirectTransport* CreateReceiveTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* receiver_call);
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
};
} // namespace webrtc
#endif // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_

3
video/end_to_end_tests/multi_stream_tests.cc
View File

@ -63,7 +63,8 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class Tester : public MultiStreamTester {
public:
explicit Tester(test::SingleThreadedTaskQueueForTesting* task_queue)
explicit Tester(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: MultiStreamTester(task_queue) {}
virtual ~Tester() {}

4
video/end_to_end_tests/network_state_tests.cc
View File

@ -156,7 +156,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
public:
explicit NetworkStateTest(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
@ -333,7 +333,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
}
}
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
rtc::CriticalSection test_crit_;
rtc::Event encoded_frames_;
rtc::Event packet_event_;

17
video/end_to_end_tests/probing_tests.cc
View File

@ -68,7 +68,7 @@ TEST_F(ProbingEndToEndTest, InitialProbing) {
public:
explicit InitialProbingTest(
bool* success,
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: ProbingTest(300000), success_(success), task_queue_(task_queue) {
*success_ = false;
}
@ -94,7 +94,7 @@ TEST_F(ProbingEndToEndTest, InitialProbing) {
private:
const int kTimeoutMs = 1000;
bool* const success_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
};
bool success = false;
@ -122,7 +122,7 @@ TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
class TriggerMidCallProbingTest : public ProbingTest {
public:
TriggerMidCallProbingTest(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
bool* success)
: ProbingTest(300000), success_(success), task_queue_(task_queue) {}
@ -176,7 +176,7 @@ TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
private:
const int kTimeoutMs = 5000;
bool* const success_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
};
bool success = false;
@ -201,8 +201,9 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
class ReconfigureTest : public ProbingTest {
public:
ReconfigureTest(test::SingleThreadedTaskQueueForTesting* task_queue,
bool* success)
ReconfigureTest(
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
bool* success)
: ProbingTest(50000), task_queue_(task_queue), success_(success) {}
void ModifyVideoConfigs(
@ -219,7 +220,7 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
auto network =
absl::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig());
@ -305,7 +306,7 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
const int kTimeoutMs = 10000;
const int kRampUpMaxDurationMs = 500;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
bool* const success_;
SimulatedNetwork* send_simulated_network_;
VideoSendStream* send_stream_;

7
video/end_to_end_tests/retransmission_tests.cc
View File

@ -137,7 +137,8 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
size_t GetNumAudioStreams() const override { return 1; }
test::PacketTransport* CreateReceiveTransport(
test::SingleThreadedTaskQueueForTesting* task_queue) override {
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
override {
test::PacketTransport* receive_transport = new test::PacketTransport(
task_queue, nullptr, this, test::PacketTransport::kReceiver,
payload_type_map_,
@ -201,7 +202,7 @@ TEST_F(RetransmissionEndToEndTest,
class KeyframeRequestObserver : public test::EndToEndTest {
public:
explicit KeyframeRequestObserver(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {}
void OnVideoStreamsCreated(
@ -233,7 +234,7 @@ TEST_F(RetransmissionEndToEndTest,
Clock* clock_;
VideoSendStream* send_stream_;
VideoReceiveStream* receive_stream_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
} test(&task_queue_);
RunBaseTest(&test);

2
video/end_to_end_tests/stats_tests.cc
View File

@ -232,7 +232,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
BuiltInNetworkBehaviorConfig network_config;
network_config.loss_percent = 5;

6
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -38,7 +38,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class RtpExtensionHeaderObserver : public test::DirectTransport {
public:
RtpExtensionHeaderObserver(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call,
const uint32_t& first_media_ssrc,
const std::map<uint32_t, uint32_t>& ssrc_map,
@ -164,7 +164,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class TransportSequenceNumberTester : public MultiStreamTester {
public:
explicit TransportSequenceNumberTester(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: MultiStreamTester(task_queue),
first_media_ssrc_(0),
observer_(nullptr) {}
@ -217,7 +217,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
}
test::DirectTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
std::map<uint8_t, MediaType> payload_type_map =
MultiStreamTester::payload_type_map_;

2
video/video_analyzer.cc
View File

@ -66,7 +66,7 @@ VideoAnalyzer::VideoAnalyzer(
bool is_quick_test_enabled,
Clock* clock,
std::string rtp_dump_name,
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: transport_(transport),
receiver_(nullptr),
call_(nullptr),

8
video/video_analyzer.h
View File

@ -45,7 +45,7 @@ class VideoAnalyzer : public PacketReceiver,
bool is_quick_test_enabled,
Clock* clock,
std::string rtp_dump_name,
test::SingleThreadedTaskQueueForTesting* task_queue);
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
~VideoAnalyzer();
virtual void SetReceiver(PacketReceiver* receiver);
@ -286,14 +286,14 @@ class VideoAnalyzer : public PacketReceiver,
std::deque<FrameComparison> comparisons_ RTC_GUARDED_BY(comparison_lock_);
bool quit_ RTC_GUARDED_BY(comparison_lock_);
rtc::Event done_;
test::SingleThreadedTaskQueueForTesting::TaskId stats_polling_task_id_
RTC_GUARDED_BY(comparison_lock_);
test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId
stats_polling_task_id_ RTC_GUARDED_BY(comparison_lock_);
bool stop_stats_poller_ RTC_GUARDED_BY(comparison_lock_);
std::unique_ptr<test::RtpFileWriter> rtp_file_writer_;
Clock* const clock_;
const int64_t start_ms_;
test::SingleThreadedTaskQueueForTesting* task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue_;
};
} // namespace webrtc

35
video/video_send_stream_tests.cc
View File

@ -556,7 +556,7 @@ class UlpfecObserver : public test::EndToEndTest {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Configure some network delay.
@ -753,7 +753,7 @@ class FlexfecObserver : public test::EndToEndTest {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
// At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
// Therefore we need some network delay.
@ -1533,7 +1533,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
}
test::PacketTransport* CreateSendTransport(
test::SingleThreadedTaskQueueForTesting* task_queue,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
Call* sender_call) override {
const int kNetworkDelayMs = 50;
BuiltInNetworkBehaviorConfig config;
@ -1674,7 +1674,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
class ChangingNetworkRouteTest : public test::EndToEndTest {
public:
explicit ChangingNetworkRouteTest(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
task_queue_(task_queue),
call_(nullptr) {
@ -1769,7 +1769,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
private:
webrtc::SequenceChecker module_process_thread_;
webrtc::SequenceChecker task_queue_thread_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
Call* call_ RTC_GUARDED_BY(task_queue_thread_);
} test(&task_queue_);
@ -1780,7 +1780,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
class ChangingTransportOverheadTest : public test::EndToEndTest {
public:
explicit ChangingTransportOverheadTest(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
task_queue_(task_queue),
call_(nullptr),
@ -1831,7 +1831,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
}
private:
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
Call* call_;
rtc::CriticalSection lock_;
int packets_sent_ RTC_GUARDED_BY(lock_);
@ -1854,9 +1854,10 @@ class MaxPaddingSetTest : public test::SendTest {
static const uint32_t kActualEncodeBitrateBps = 40000;
static const uint32_t kMinPacketsToSend = 50;
MaxPaddingSetTest(bool test_switch_content_type,
T* stream_reset_fun,
test::SingleThreadedTaskQueueForTesting* task_queue)
MaxPaddingSetTest(
bool test_switch_content_type,
T* stream_reset_fun,
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: SendTest(test::CallTest::kDefaultTimeoutMs),
running_without_padding_(test_switch_content_type),
stream_resetter_(stream_reset_fun),
@ -1959,7 +1960,7 @@ class MaxPaddingSetTest : public test::SendTest {
uint32_t packets_sent_ RTC_GUARDED_BY(task_queue_thread_) = 0;
bool running_without_padding_ RTC_GUARDED_BY(task_queue_thread_);
T* const stream_resetter_;
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
};
TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) {
@ -2322,7 +2323,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
class EncoderStateObserver : public test::SendTest, public VideoEncoder {
public:
explicit EncoderStateObserver(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: SendTest(kDefaultTimeoutMs),
task_queue_(task_queue),
stream_(nullptr),
@ -2425,7 +2426,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
}
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
rtc::CriticalSection crit_;
VideoSendStream* stream_;
bool initialized_ RTC_GUARDED_BY(crit_);
@ -2782,7 +2783,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
public test::FakeEncoder {
public:
explicit EncoderBitrateThresholdObserver(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: SendTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
@ -2946,7 +2947,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
EXPECT_EQ(1, num_encoder_initializations_);
}
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
rtc::Event create_rate_allocator_event_;
rtc::Event init_encode_event_;
rtc::Event bitrate_changed_event_;
@ -3623,7 +3624,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
public test::FakeEncoder {
public:
explicit RemoveOverheadFromBandwidthTest(
test::SingleThreadedTaskQueueForTesting* task_queue)
test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
@ -3688,7 +3689,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
}
private:
test::SingleThreadedTaskQueueForTesting* const task_queue_;
test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
test::VideoEncoderProxyFactory encoder_factory_;
Call* call_;
rtc::CriticalSection crit_;