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

Migrate remaining webrtc usage of TaskQueueBase to absl::AnyInvocable

Browse Source 
Bug: webrtc:14245
Change-Id: I8de2c23da5fbdfc0b1efbbe07fb6e8de744424a3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/268191
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37565}
This commit is contained in:
Danil Chapovalov 2022-07-19 13:07:12 +02:00 committed by WebRTC LUCI CQ
parent 489f648ea3
commit c05a1be5b4
37 changed files with 85 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/metronome/test/BUILD.gn
View File

@ -18,7 +18,6 @@ rtc_library("fake_metronome") {
"..:metronome", "..:metronome",
"../..:priority", "../..:priority",
"../..:sequence_checker", "../..:sequence_checker",
"../../../api/task_queue:to_queued_task",
"../../../rtc_base:macromagic", "../../../rtc_base:macromagic",
"../../../rtc_base:rtc_event", "../../../rtc_base:rtc_event",
"../../../rtc_base:rtc_task_queue", "../../../rtc_base:rtc_task_queue",

6
api/metronome/test/fake_metronome.cc
View File

@ -13,7 +13,6 @@
#include "api/priority.h" #include "api/priority.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/task_queue_factory.h" #include "api/task_queue/task_queue_factory.h"
#include "api/task_queue/to_queued_task.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/task_utils/repeating_task.h" #include "rtc_base/task_utils/repeating_task.h"
@ -41,8 +40,7 @@ size_t ForcedTickMetronome::NumListeners() {
void ForcedTickMetronome::Tick() { void ForcedTickMetronome::Tick() {
for (auto* listener : listeners_) { for (auto* listener : listeners_) {
listener->OnTickTaskQueue()->PostTask( listener->OnTickTaskQueue()->PostTask([listener] { listener->OnTick(); });
ToQueuedTask([listener] { listener->OnTick(); }));
} }
} }
@ -66,7 +64,7 @@ void FakeMetronome::AddListener(TickListener* listener) {
return TimeDelta::PlusInfinity(); return TimeDelta::PlusInfinity();
for (auto* listener : listeners_) { for (auto* listener : listeners_) {
listener->OnTickTaskQueue()->PostTask( listener->OnTickTaskQueue()->PostTask(
ToQueuedTask([listener] { listener->OnTick(); })); [listener] { listener->OnTick(); });
} }
return tick_period_; return tick_period_;
}); });

2
api/task_queue/test/BUILD.gn
View File

@ -13,6 +13,8 @@ rtc_library("mock_task_queue_base") {
sources = [ "mock_task_queue_base.h" ] sources = [ "mock_task_queue_base.h" ]
deps = [ deps = [
"../../../api/task_queue:task_queue", "../../../api/task_queue:task_queue",
"../../../api/units:time_delta",
"../../../test:test_support", "../../../test:test_support",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/functional:any_invocable" ]
} }

19
api/task_queue/test/mock_task_queue_base.h
View File

@ -11,20 +11,25 @@
#ifndef API_TASK_QUEUE_TEST_MOCK_TASK_QUEUE_BASE_H_ #ifndef API_TASK_QUEUE_TEST_MOCK_TASK_QUEUE_BASE_H_
#define API_TASK_QUEUE_TEST_MOCK_TASK_QUEUE_BASE_H_ #define API_TASK_QUEUE_TEST_MOCK_TASK_QUEUE_BASE_H_
#include <memory> #include "absl/functional/any_invocable.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "test/gmock.h" #include "test/gmock.h"
namespace webrtc { namespace webrtc {
class MockTaskQueueBase : public TaskQueueBase { class MockTaskQueueBase : public TaskQueueBase {
public: public:
MOCK_METHOD0(Delete, void()); MOCK_METHOD(void, Delete, (), (override));
MOCK_METHOD1(PostTask, void(std::unique_ptr<QueuedTask>)); MOCK_METHOD(void, PostTask, (absl::AnyInvocable<void() &&>), (override));
MOCK_METHOD2(PostDelayedTask, void(std::unique_ptr<QueuedTask>, uint32_t)); MOCK_METHOD(void,
MOCK_METHOD2(PostDelayedHighPrecisionTask, PostDelayedTask,
void(std::unique_ptr<QueuedTask>, uint32_t)); (absl::AnyInvocable<void() &&>, TimeDelta),
(override));
MOCK_METHOD(void,
PostDelayedHighPrecisionTask,
(absl::AnyInvocable<void() &&>, TimeDelta),
(override));
}; };
} // namespace webrtc } // namespace webrtc

4
audio/BUILD.gn
View File

@ -62,7 +62,6 @@ rtc_library("audio") {
"../api/rtc_event_log", "../api/rtc_event_log",
"../api/task_queue", "../api/task_queue",
"../api/task_queue:pending_task_safety_flag", "../api/task_queue:pending_task_safety_flag",
"../api/task_queue:to_queued_task",
"../api/transport/rtp:rtp_source", "../api/transport/rtp:rtp_source",
"../call:audio_sender_interface", "../call:audio_sender_interface",
"../call:bitrate_allocator", "../call:bitrate_allocator",
@ -168,6 +167,7 @@ if (rtc_include_tests) {
"../api/crypto:frame_decryptor_interface", "../api/crypto:frame_decryptor_interface",
"../api/rtc_event_log", "../api/rtc_event_log",
"../api/task_queue:default_task_queue_factory", "../api/task_queue:default_task_queue_factory",
"../api/task_queue/test:mock_task_queue_base",
"../api/units:time_delta", "../api/units:time_delta",
"../call:mock_bitrate_allocator", "../call:mock_bitrate_allocator",
"../call:mock_call_interfaces", "../call:mock_call_interfaces",
@ -324,7 +324,7 @@ if (rtc_include_tests) {
"../test:test_support", "../test:test_support",
"//testing/gtest", "//testing/gtest",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/functional:any_invocable" ]
data = [ "//resources/voice_engine/audio_dtx16.wav" ] data = [ "//resources/voice_engine/audio_dtx16.wav" ]
} }
} }

11
audio/audio_state_unittest.cc
View File

@ -14,6 +14,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "api/task_queue/test/mock_task_queue_base.h"
#include "call/test/mock_audio_send_stream.h" #include "call/test/mock_audio_send_stream.h"
#include "modules/audio_device/include/mock_audio_device.h" #include "modules/audio_device/include/mock_audio_device.h"
#include "modules/audio_mixer/audio_mixer_impl.h" #include "modules/audio_mixer/audio_mixer_impl.h"
@ -34,18 +35,14 @@ constexpr int kSampleRate = 16000;
constexpr int kNumberOfChannels = 1; constexpr int kNumberOfChannels = 1;
struct FakeAsyncAudioProcessingHelper { struct FakeAsyncAudioProcessingHelper {
class FakeTaskQueue : public StrictMock<TaskQueueBase> { class FakeTaskQueue : public StrictMock<MockTaskQueueBase> {
public: public:
FakeTaskQueue() = default; FakeTaskQueue() = default;
void Delete() override { delete this; } void Delete() override { delete this; }
void PostTask(std::unique_ptr<QueuedTask> task) override { void PostTask(absl::AnyInvocable<void() &&> task) override {
std::move(task)->Run(); std::move(task)();
} }
MOCK_METHOD(void,
PostDelayedTask,
(std::unique_ptr<QueuedTask> task, uint32_t milliseconds),
(override));
}; };
class FakeTaskQueueFactory : public TaskQueueFactory { class FakeTaskQueueFactory : public TaskQueueFactory {

3
audio/channel_receive.cc
View File

@ -23,7 +23,6 @@
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/pending_task_safety_flag.h" #include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/task_queue/to_queued_task.h"
#include "audio/audio_level.h" #include "audio/audio_level.h"
#include "audio/channel_receive_frame_transformer_delegate.h" #include "audio/channel_receive_frame_transformer_delegate.h"
#include "audio/channel_send.h" #include "audio/channel_send.h"
@ -482,7 +481,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
++audio_frame_interval_count_; ++audio_frame_interval_count_;
if (audio_frame_interval_count_ >= kHistogramReportingInterval) { if (audio_frame_interval_count_ >= kHistogramReportingInterval) {
audio_frame_interval_count_ = 0; audio_frame_interval_count_ = 0;
worker_thread_->PostTask(ToQueuedTask(worker_safety_, [this]() { worker_thread_->PostTask(SafeTask(worker_safety_.flag(), [this]() {
RTC_DCHECK_RUN_ON(&worker_thread_checker_); RTC_DCHECK_RUN_ON(&worker_thread_checker_);
RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.TargetJitterBufferDelayMs", RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.TargetJitterBufferDelayMs",
acm_receiver_.TargetDelayMs()); acm_receiver_.TargetDelayMs());

5
audio/channel_receive_frame_transformer_delegate.cc
View File

@ -12,7 +12,6 @@
#include <utility> #include <utility>
#include "api/task_queue/to_queued_task.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
namespace webrtc { namespace webrtc {
@ -80,10 +79,10 @@ void ChannelReceiveFrameTransformerDelegate::Transform(
void ChannelReceiveFrameTransformerDelegate::OnTransformedFrame( void ChannelReceiveFrameTransformerDelegate::OnTransformedFrame(
std::unique_ptr<TransformableFrameInterface> frame) { std::unique_ptr<TransformableFrameInterface> frame) {
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate(this); rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate(this);
channel_receive_thread_->PostTask(ToQueuedTask( channel_receive_thread_->PostTask(
[delegate = std::move(delegate), frame = std::move(frame)]() mutable { [delegate = std::move(delegate), frame = std::move(frame)]() mutable {
delegate->ReceiveFrame(std::move(frame)); delegate->ReceiveFrame(std::move(frame));
})); });
} }
void ChannelReceiveFrameTransformerDelegate::ReceiveFrame( void ChannelReceiveFrameTransformerDelegate::ReceiveFrame(

28
audio/test/audio_bwe_integration_test.cc
View File

@ -12,7 +12,7 @@
#include <memory> #include <memory>
#include "api/task_queue/queued_task.h" #include "absl/functional/any_invocable.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "call/fake_network_pipe.h" #include "call/fake_network_pipe.h"
#include "call/simulated_network.h" #include "call/simulated_network.h"
@ -84,21 +84,15 @@ void AudioBweTest::PerformTest() {
SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraProcessTimeMs); SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraProcessTimeMs);
} }
class StatsPollTask : public QueuedTask { absl::AnyInvocable<void() &&> StatsPollTask(Call* sender_call) {
public: RTC_CHECK(sender_call);
explicit StatsPollTask(Call* sender_call) : sender_call_(sender_call) {} return [sender_call] {
Call::Stats call_stats = sender_call->GetStats();
private:
bool Run() override {
RTC_CHECK(sender_call_);
Call::Stats call_stats = sender_call_->GetStats();
EXPECT_GT(call_stats.send_bandwidth_bps, 25000); EXPECT_GT(call_stats.send_bandwidth_bps, 25000);
TaskQueueBase::Current()->PostDelayedTask(std::unique_ptr<QueuedTask>(this), TaskQueueBase::Current()->PostDelayedTask(StatsPollTask(sender_call),
100); TimeDelta::Millis(100));
return false; };
} }
Call* sender_call_;
};
class NoBandwidthDropAfterDtx : public AudioBweTest { class NoBandwidthDropAfterDtx : public AudioBweTest {
public: public:
@ -144,8 +138,8 @@ class NoBandwidthDropAfterDtx : public AudioBweTest {
} }
void PerformTest() override { void PerformTest() override {
stats_poller_.PostDelayedTask(std::make_unique<StatsPollTask>(sender_call_), stats_poller_.PostDelayedTask(StatsPollTask(sender_call_),
100); TimeDelta::Millis(100));
sender_call_->OnAudioTransportOverheadChanged(0); sender_call_->OnAudioTransportOverheadChanged(0);
AudioBweTest::PerformTest(); AudioBweTest::PerformTest();
} }

2
audio/voip/test/BUILD.gn
View File

@ -15,6 +15,7 @@ if (rtc_include_tests) {
sources = [ "mock_task_queue.h" ] sources = [ "mock_task_queue.h" ]
deps = [ deps = [
"../../../api/task_queue:task_queue", "../../../api/task_queue:task_queue",
"../../../api/task_queue/test:mock_task_queue_base",
"../../../test:test_support", "../../../test:test_support",
] ]
} }
@ -56,6 +57,7 @@ if (rtc_include_tests) {
"../../../test:mock_transport", "../../../test:mock_transport",
"../../../test:test_support", "../../../test:test_support",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/functional:any_invocable" ]
} }
rtc_library("audio_ingress_unittests") { rtc_library("audio_ingress_unittests") {

4
audio/voip/test/audio_channel_unittest.cc
View File

@ -9,6 +9,8 @@
*/ */
#include "audio/voip/audio_channel.h" #include "audio/voip/audio_channel.h"
#include "absl/functional/any_invocable.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h" #include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h" #include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/call/transport.h" #include "api/call/transport.h"
@ -49,7 +51,7 @@ class AudioChannelTest : public ::testing::Test {
// By default, run the queued task immediately. // By default, run the queued task immediately.
ON_CALL(task_queue_, PostTask) ON_CALL(task_queue_, PostTask)
.WillByDefault( .WillByDefault(
Invoke([&](std::unique_ptr<QueuedTask> task) { task->Run(); })); [](absl::AnyInvocable<void() &&> task) { std::move(task)(); });
} }
void SetUp() override { audio_channel_ = CreateAudioChannel(kLocalSsrc); } void SetUp() override { audio_channel_ = CreateAudioChannel(kLocalSsrc); }

9
audio/voip/test/mock_task_queue.h
View File

@ -14,13 +14,14 @@
#include <memory> #include <memory>
#include "api/task_queue/task_queue_factory.h" #include "api/task_queue/task_queue_factory.h"
#include "api/task_queue/test/mock_task_queue_base.h"
#include "test/gmock.h" #include "test/gmock.h"
namespace webrtc { namespace webrtc {
// MockTaskQueue enables immediate task run from global TaskQueueBase. // MockTaskQueue enables immediate task run from global TaskQueueBase.
// It's necessary for some tests depending on TaskQueueBase internally. // It's necessary for some tests depending on TaskQueueBase internally.
class MockTaskQueue : public TaskQueueBase { class MockTaskQueue : public MockTaskQueueBase {
public: public:
MockTaskQueue() : current_(this) {} MockTaskQueue() : current_(this) {}
@ -28,12 +29,6 @@ class MockTaskQueue : public TaskQueueBase {
// hold onto current global TaskQueueBase throughout the testing. // hold onto current global TaskQueueBase throughout the testing.
void Delete() override {} void Delete() override {}
MOCK_METHOD(void, PostTask, (std::unique_ptr<QueuedTask>), (override));
MOCK_METHOD(void,
PostDelayedTask,
(std::unique_ptr<QueuedTask>, uint32_t),
(override));
private: private:
CurrentTaskQueueSetter current_; CurrentTaskQueueSetter current_;
}; };

2
call/adaptation/BUILD.gn
View File

@ -39,7 +39,6 @@ rtc_library("resource_adaptation") {
"../../api:sequence_checker", "../../api:sequence_checker",
"../../api/adaptation:resource_adaptation_api", "../../api/adaptation:resource_adaptation_api",
"../../api/task_queue:task_queue", "../../api/task_queue:task_queue",
"../../api/task_queue:to_queued_task",
"../../api/video:video_adaptation", "../../api/video:video_adaptation",
"../../api/video:video_frame", "../../api/video:video_frame",
"../../api/video:video_stream_encoder", "../../api/video:video_stream_encoder",
@ -121,7 +120,6 @@ if (rtc_include_tests) {
"../../api:sequence_checker", "../../api:sequence_checker",
"../../api/adaptation:resource_adaptation_api", "../../api/adaptation:resource_adaptation_api",
"../../api/task_queue:task_queue", "../../api/task_queue:task_queue",
"../../api/task_queue:to_queued_task",
"../../api/video:video_stream_encoder", "../../api/video:video_stream_encoder",
"../../test:test_support", "../../test:test_support",
] ]

1
call/adaptation/resource_adaptation_processor.cc
View File

@ -17,7 +17,6 @@
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/to_queued_task.h"
#include "api/video/video_adaptation_counters.h" #include "api/video/video_adaptation_counters.h"
#include "call/adaptation/video_stream_adapter.h" #include "call/adaptation/video_stream_adapter.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"

3
common_video/incoming_video_stream.cc
View File

@ -14,6 +14,7 @@
#include <utility> #include <utility>
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/units/time_delta.h"
#include "common_video/video_render_frames.h" #include "common_video/video_render_frames.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/trace_event.h" #include "rtc_base/trace_event.h"
@ -58,7 +59,7 @@ void IncomingVideoStream::Dequeue() {
if (render_buffers_.HasPendingFrames()) { if (render_buffers_.HasPendingFrames()) {
uint32_t wait_time = render_buffers_.TimeToNextFrameRelease(); uint32_t wait_time = render_buffers_.TimeToNextFrameRelease();
incoming_render_queue_.PostDelayedHighPrecisionTask( incoming_render_queue_.PostDelayedHighPrecisionTask(
ToQueuedTask([this]() { Dequeue(); }), wait_time); [this]() { Dequeue(); }, TimeDelta::Millis(wait_time));
} }
} }

1
logging/BUILD.gn
View File

@ -367,6 +367,7 @@ if (rtc_enable_protobuf) {
"../api:sequence_checker", "../api:sequence_checker",
"../api/rtc_event_log", "../api/rtc_event_log",
"../api/task_queue", "../api/task_queue",
"../api/units:time_delta",
"../rtc_base:checks", "../rtc_base:checks",
"../rtc_base:logging", "../rtc_base:logging",
"../rtc_base:macromagic", "../rtc_base:macromagic",

5
logging/rtc_event_log/rtc_event_log_impl.cc
View File

@ -18,8 +18,8 @@
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/task_queue/queued_task.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h" #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h" #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -182,7 +182,8 @@ void RtcEventLogImpl::ScheduleOutput() {
const int64_t time_since_output_ms = now_ms - last_output_ms_; const int64_t time_since_output_ms = now_ms - last_output_ms_;
const uint32_t delay = rtc::SafeClamp( const uint32_t delay = rtc::SafeClamp(
*output_period_ms_ - time_since_output_ms, 0, *output_period_ms_); *output_period_ms_ - time_since_output_ms, 0, *output_period_ms_);
task_queue_->PostDelayedTask(ToQueuedTask(std::move(output_task)), delay); task_queue_->PostDelayedTask(std::move(output_task),
TimeDelta::Millis(delay));
} }
} }

3
media/BUILD.gn
View File

@ -65,7 +65,6 @@ rtc_library("rtc_media_base") {
"../api/crypto:frame_encryptor_interface", "../api/crypto:frame_encryptor_interface",
"../api/crypto:options", "../api/crypto:options",
"../api/task_queue:pending_task_safety_flag", "../api/task_queue:pending_task_safety_flag",
"../api/task_queue:to_queued_task",
"../api/transport:datagram_transport_interface", "../api/transport:datagram_transport_interface",
"../api/transport:stun_types", "../api/transport:stun_types",
"../api/transport/rtp:rtp_source", "../api/transport/rtp:rtp_source",
@ -278,7 +277,6 @@ rtc_library("rtc_audio_video") {
"../api/audio_codecs:audio_codecs_api", "../api/audio_codecs:audio_codecs_api",
"../api/task_queue", "../api/task_queue",
"../api/task_queue:pending_task_safety_flag", "../api/task_queue:pending_task_safety_flag",
"../api/task_queue:to_queued_task",
"../api/transport:bitrate_settings", "../api/transport:bitrate_settings",
"../api/transport:field_trial_based_config", "../api/transport:field_trial_based_config",
"../api/transport/rtp:rtp_source", "../api/transport/rtp:rtp_source",
@ -422,7 +420,6 @@ if (rtc_build_dcsctp) {
"../api:array_view", "../api:array_view",
"../api/task_queue:pending_task_safety_flag", "../api/task_queue:pending_task_safety_flag",
"../api/task_queue:task_queue", "../api/task_queue:task_queue",
"../api/task_queue:to_queued_task",
"../media:rtc_media_base", "../media:rtc_media_base",
"../net/dcsctp/public:factory", "../net/dcsctp/public:factory",
"../net/dcsctp/public:socket", "../net/dcsctp/public:socket",

9
media/base/media_channel.cc
View File

@ -10,7 +10,6 @@
#include "media/base/media_channel.h" #include "media/base/media_channel.h"
#include "api/task_queue/to_queued_task.h"
#include "media/base/rtp_utils.h" #include "media/base/rtp_utils.h"
namespace cricket { namespace cricket {
@ -18,8 +17,8 @@ using webrtc::FrameDecryptorInterface;
using webrtc::FrameEncryptorInterface; using webrtc::FrameEncryptorInterface;
using webrtc::FrameTransformerInterface; using webrtc::FrameTransformerInterface;
using webrtc::PendingTaskSafetyFlag; using webrtc::PendingTaskSafetyFlag;
using webrtc::SafeTask;
using webrtc::TaskQueueBase; using webrtc::TaskQueueBase;
using webrtc::ToQueuedTask;
using webrtc::VideoTrackInterface; using webrtc::VideoTrackInterface;
VideoOptions::VideoOptions() VideoOptions::VideoOptions()
@ -126,7 +125,7 @@ void MediaChannel::SetPreferredDscp(rtc::DiffServCodePoint new_dscp) {
// This is currently the common path as the derived channel classes // This is currently the common path as the derived channel classes
// get called on the worker thread. There are still some tests though // get called on the worker thread. There are still some tests though
// that call directly on the network thread. // that call directly on the network thread.
network_thread_->PostTask(ToQueuedTask( network_thread_->PostTask(SafeTask(
network_safety_, [this, new_dscp]() { SetPreferredDscp(new_dscp); })); network_safety_, [this, new_dscp]() { SetPreferredDscp(new_dscp); }));
return; return;
} }
@ -190,7 +189,7 @@ void MediaChannel::SendRtp(const uint8_t* data,
if (network_thread_->IsCurrent()) { if (network_thread_->IsCurrent()) {
send(); send();
} else { } else {
network_thread_->PostTask(ToQueuedTask(network_safety_, std::move(send))); network_thread_->PostTask(SafeTask(network_safety_, std::move(send)));
} }
} }
@ -207,7 +206,7 @@ void MediaChannel::SendRtcp(const uint8_t* data, size_t len) {
if (network_thread_->IsCurrent()) { if (network_thread_->IsCurrent()) {
send(); send();
} else { } else {
network_thread_->PostTask(ToQueuedTask(network_safety_, std::move(send))); network_thread_->PostTask(SafeTask(network_safety_, std::move(send)));
} }
} }

10
media/engine/webrtc_video_engine.cc
View File

@ -920,7 +920,7 @@ bool WebRtcVideoChannel::SetSendParameters(const VideoSendParameters& params) {
void WebRtcVideoChannel::RequestEncoderFallback() { void WebRtcVideoChannel::RequestEncoderFallback() {
if (!worker_thread_->IsCurrent()) { if (!worker_thread_->IsCurrent()) {
worker_thread_->PostTask( worker_thread_->PostTask(
ToQueuedTask(task_safety_, [this] { RequestEncoderFallback(); })); SafeTask(task_safety_.flag(), [this] { RequestEncoderFallback(); }));
return; return;
} }
@ -942,7 +942,7 @@ void WebRtcVideoChannel::RequestEncoderSwitch(
bool allow_default_fallback) { bool allow_default_fallback) {
if (!worker_thread_->IsCurrent()) { if (!worker_thread_->IsCurrent()) {
worker_thread_->PostTask( worker_thread_->PostTask(
ToQueuedTask(task_safety_, [this, format, allow_default_fallback] { SafeTask(task_safety_.flag(), [this, format, allow_default_fallback] {
RequestEncoderSwitch(format, allow_default_fallback); RequestEncoderSwitch(format, allow_default_fallback);
})); }));
return; return;
@ -1724,7 +1724,7 @@ void WebRtcVideoChannel::OnPacketReceived(rtc::CopyOnWriteBuffer packet,
// to a common implementation and provide a callback on the worker thread // to a common implementation and provide a callback on the worker thread
// for the exception case (DELIVERY_UNKNOWN_SSRC) and how retry is attempted. // for the exception case (DELIVERY_UNKNOWN_SSRC) and how retry is attempted.
worker_thread_->PostTask( worker_thread_->PostTask(
ToQueuedTask(task_safety_, [this, packet, packet_time_us] { SafeTask(task_safety_.flag(), [this, packet, packet_time_us] {
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
const webrtc::PacketReceiver::DeliveryStatus delivery_result = const webrtc::PacketReceiver::DeliveryStatus delivery_result =
call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, packet, call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, packet,
@ -1877,8 +1877,8 @@ void WebRtcVideoChannel::OnNetworkRouteChanged(
absl::string_view transport_name, absl::string_view transport_name,
const rtc::NetworkRoute& network_route) { const rtc::NetworkRoute& network_route) {
RTC_DCHECK_RUN_ON(&network_thread_checker_); RTC_DCHECK_RUN_ON(&network_thread_checker_);
worker_thread_->PostTask(ToQueuedTask( worker_thread_->PostTask(SafeTask(
task_safety_, task_safety_.flag(),
[this, name = std::string(transport_name), route = network_route] { [this, name = std::string(transport_name), route = network_route] {
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
webrtc::RtpTransportControllerSendInterface* transport = webrtc::RtpTransportControllerSendInterface* transport =

9
media/engine/webrtc_voice_engine.cc
View File

@ -25,7 +25,6 @@
#include "api/call/audio_sink.h" #include "api/call/audio_sink.h"
#include "api/field_trials_view.h" #include "api/field_trials_view.h"
#include "api/task_queue/pending_task_safety_flag.h" #include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/to_queued_task.h"
#include "media/base/audio_source.h" #include "media/base/audio_source.h"
#include "media/base/media_constants.h" #include "media/base/media_constants.h"
#include "media/base/stream_params.h" #include "media/base/stream_params.h"
@ -2152,8 +2151,8 @@ void WebRtcVoiceMediaChannel::OnPacketReceived(rtc::CopyOnWriteBuffer packet,
// consistency it would be good to move the interaction with call_->Receiver() // consistency it would be good to move the interaction with call_->Receiver()
// to a common implementation and provide a callback on the worker thread // to a common implementation and provide a callback on the worker thread
// for the exception case (DELIVERY_UNKNOWN_SSRC) and how retry is attempted. // for the exception case (DELIVERY_UNKNOWN_SSRC) and how retry is attempted.
worker_thread_->PostTask(ToQueuedTask(task_safety_, [this, packet, worker_thread_->PostTask(SafeTask(task_safety_.flag(), [this, packet,
packet_time_us] { packet_time_us] {
RTC_DCHECK_RUN_ON(worker_thread_); RTC_DCHECK_RUN_ON(worker_thread_);
webrtc::PacketReceiver::DeliveryStatus delivery_result = webrtc::PacketReceiver::DeliveryStatus delivery_result =
@ -2232,8 +2231,8 @@ void WebRtcVoiceMediaChannel::OnNetworkRouteChanged(
call_->OnAudioTransportOverheadChanged(network_route.packet_overhead); call_->OnAudioTransportOverheadChanged(network_route.packet_overhead);
worker_thread_->PostTask(ToQueuedTask( worker_thread_->PostTask(SafeTask(
task_safety_, task_safety_.flag(),
[this, name = std::string(transport_name), route = network_route] { [this, name = std::string(transport_name), route = network_route] {
RTC_DCHECK_RUN_ON(worker_thread_); RTC_DCHECK_RUN_ON(worker_thread_);
call_->GetTransportControllerSend()->OnNetworkRouteChanged(name, route); call_->GetTransportControllerSend()->OnNetworkRouteChanged(name, route);

6
modules/audio_device/audio_device_buffer.cc
View File

@ -477,10 +477,8 @@ void AudioDeviceBuffer::LogStats(LogState state) {
// Keep posting new (delayed) tasks until state is changed to kLogStop. // Keep posting new (delayed) tasks until state is changed to kLogStop.
task_queue_.PostDelayedTask( task_queue_.PostDelayedTask(
ToQueuedTask([this] { [this] { AudioDeviceBuffer::LogStats(AudioDeviceBuffer::LOG_ACTIVE); },
AudioDeviceBuffer::LogStats(AudioDeviceBuffer::LOG_ACTIVE); TimeDelta::Millis(time_to_wait_ms));
}),
time_to_wait_ms);
} }
void AudioDeviceBuffer::ResetRecStats() { void AudioDeviceBuffer::ResetRecStats() {

1
net/dcsctp/socket/BUILD.gn
View File

@ -229,7 +229,6 @@ if (rtc_include_tests) {
"../../../api:create_network_emulation_manager", "../../../api:create_network_emulation_manager",
"../../../api:network_emulation_manager_api", "../../../api:network_emulation_manager_api",
"../../../api/task_queue:task_queue", "../../../api/task_queue:task_queue",
"../../../api/task_queue:to_queued_task",
"../../../api/units:time_delta", "../../../api/units:time_delta",
"../../../call:simulated_network", "../../../call:simulated_network",
"../../../rtc_base:checks", "../../../rtc_base:checks",

1
net/dcsctp/timer/task_queue_timeout_test.cc
View File

@ -11,7 +11,6 @@
#include <memory> #include <memory>
#include "api/task_queue/queued_task.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/task_queue/test/mock_task_queue_base.h" #include "api/task_queue/test/mock_task_queue_base.h"
#include "rtc_base/gunit.h" #include "rtc_base/gunit.h"

1
pc/proxy.h
View File

@ -66,7 +66,6 @@
#include <utility> #include <utility>
#include "api/scoped_refptr.h" #include "api/scoped_refptr.h"
#include "api/task_queue/queued_task.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/location.h" #include "rtc_base/location.h"

1
pc/rtc_stats_collector.cc
View File

@ -31,7 +31,6 @@
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/stats/rtc_stats.h" #include "api/stats/rtc_stats.h"
#include "api/stats/rtcstats_objects.h" #include "api/stats/rtcstats_objects.h"
#include "api/task_queue/queued_task.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "api/video/video_content_type.h" #include "api/video/video_content_type.h"
#include "common_video/include/quality_limitation_reason.h" #include "common_video/include/quality_limitation_reason.h"

1
rtc_base/BUILD.gn
View File

@ -601,7 +601,6 @@ rtc_library("rtc_task_queue") {
deps = [ deps = [
":macromagic", ":macromagic",
"../api/task_queue", "../api/task_queue",
"../api/task_queue:to_queued_task",
"system:rtc_export", "system:rtc_export",
] ]
absl_deps = [ absl_deps = [

22
rtc_base/task_queue.cc
View File

@ -29,26 +29,4 @@ bool TaskQueue::IsCurrent() const {
return impl_->IsCurrent(); return impl_->IsCurrent();
} }
void TaskQueue::PostTask(std::unique_ptr<webrtc::QueuedTask> task) {
impl_->PostTask(std::move(task));
}
void TaskQueue::PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
uint32_t milliseconds) {
impl_->PostDelayedTask(std::move(task), milliseconds);
}
void TaskQueue::PostDelayedHighPrecisionTask(
std::unique_ptr<webrtc::QueuedTask> task,
uint32_t milliseconds) {
impl_->PostDelayedHighPrecisionTask(std::move(task), milliseconds);
}
void TaskQueue::PostDelayedTaskWithPrecision(
webrtc::TaskQueueBase::DelayPrecision precision,
std::unique_ptr<webrtc::QueuedTask> task,
uint32_t milliseconds) {
impl_->PostDelayedTaskWithPrecision(precision, std::move(task), milliseconds);
}
} // namespace rtc } // namespace rtc

22
rtc_base/task_queue.h
View File

@ -21,7 +21,6 @@
#include "api/task_queue/queued_task.h" #include "api/task_queue/queued_task.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h" #include "api/task_queue/task_queue_factory.h"
#include "api/task_queue/to_queued_task.h"
#include "rtc_base/system/rtc_export.h" #include "rtc_base/system/rtc_export.h"
#include "rtc_base/thread_annotations.h" #include "rtc_base/thread_annotations.h"
@ -93,22 +92,17 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue {
webrtc::TaskQueueBase* Get() { return impl_; } webrtc::TaskQueueBase* Get() { return impl_; }
// TODO(tommi): For better debuggability, implement RTC_FROM_HERE. // TODO(tommi): For better debuggability, implement RTC_FROM_HERE.
// Ownership of the task is passed to PostTask.
void PostTask(std::unique_ptr<webrtc::QueuedTask> task);
// See webrtc::TaskQueueBase for precision expectations.
void PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
uint32_t milliseconds);
void PostDelayedHighPrecisionTask(std::unique_ptr<webrtc::QueuedTask> task,
uint32_t milliseconds);
void PostDelayedTaskWithPrecision(
webrtc::TaskQueueBase::DelayPrecision precision,
std::unique_ptr<webrtc::QueuedTask> task,
uint32_t milliseconds);
void PostTask(absl::AnyInvocable<void() &&> task) { void PostTask(absl::AnyInvocable<void() &&> task) {
impl_->PostTask(std::move(task)); impl_->PostTask(std::move(task));
} }
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
webrtc::TimeDelta delay) {
impl_->PostDelayedTask(std::move(task), delay);
}
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
webrtc::TimeDelta delay) {
impl_->PostDelayedHighPrecisionTask(std::move(task), delay);
}
private: private:
webrtc::TaskQueueBase* const impl_; webrtc::TaskQueueBase* const impl_;

8
rtc_base/task_queue_unittest.cc
View File

@ -16,11 +16,13 @@
#endif #endif
#include <stdint.h> #include <stdint.h>
#include <memory> #include <memory>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "api/units/time_delta.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/task_queue_for_test.h" #include "rtc_base/task_queue_for_test.h"
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"
@ -29,6 +31,7 @@
namespace rtc { namespace rtc {
namespace { namespace {
using ::webrtc::TimeDelta;
// Noop on all platforms except Windows, where it turns on high precision // Noop on all platforms except Windows, where it turns on high precision
// multimedia timers which increases the precision of TimeMillis() while in // multimedia timers which increases the precision of TimeMillis() while in
// scope. // scope.
@ -66,9 +69,8 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
webrtc::TaskQueueForTest queue(kQueueName, TaskQueue::Priority::HIGH); webrtc::TaskQueueForTest queue(kQueueName, TaskQueue::Priority::HIGH);
uint32_t start = Time(); uint32_t start = Time();
queue.PostDelayedTask( queue.PostDelayedTask([&event, &queue] { CheckCurrent(&event, &queue); },
webrtc::ToQueuedTask([&event, &queue] { CheckCurrent(&event, &queue); }), TimeDelta::Millis(3));
3);
EXPECT_TRUE(event.Wait(1000)); EXPECT_TRUE(event.Wait(1000));
uint32_t end = TimeMillis(); uint32_t end = TimeMillis();
// These tests are a little relaxed due to how "powerful" our test bots can // These tests are a little relaxed due to how "powerful" our test bots can

1
sdk/BUILD.gn
View File

@ -1563,7 +1563,6 @@ if (is_ios || is_mac) {
"../api:field_trials_view", "../api:field_trials_view",
"../api:sequence_checker", "../api:sequence_checker",
"../api/task_queue:pending_task_safety_flag", "../api/task_queue:pending_task_safety_flag",
"../api/task_queue:to_queued_task",
"../rtc_base", "../rtc_base",
"../rtc_base:logging", "../rtc_base:logging",
"../rtc_base:macromagic", "../rtc_base:macromagic",

2
sdk/android/BUILD.gn
View File

@ -583,7 +583,6 @@ if (current_os == "linux" || is_android) {
"../../api:scoped_refptr", "../../api:scoped_refptr",
"../../api:sequence_checker", "../../api:sequence_checker",
"../../api/task_queue:pending_task_safety_flag", "../../api/task_queue:pending_task_safety_flag",
"../../api/task_queue:to_queued_task",
"../../rtc_base", "../../rtc_base",
"../../rtc_base:checks", "../../rtc_base:checks",
"../../rtc_base:ip_address", "../../rtc_base:ip_address",
@ -675,7 +674,6 @@ if (current_os == "linux" || is_android) {
"../../api:media_stream_interface", "../../api:media_stream_interface",
"../../api:sequence_checker", "../../api:sequence_checker",
"../../api/task_queue", "../../api/task_queue",
"../../api/task_queue:to_queued_task",
"../../api/video:encoded_image", "../../api/video:encoded_image",
"../../api/video:render_resolution", "../../api/video:render_resolution",
"../../api/video:video_frame", "../../api/video:video_frame",

15
sdk/android/src/jni/android_network_monitor.cc
View File

@ -19,7 +19,6 @@
#endif #endif
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/to_queued_task.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/ip_address.h" #include "rtc_base/ip_address.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
@ -631,7 +630,7 @@ AndroidNetworkMonitorFactory::CreateNetworkMonitor(
void AndroidNetworkMonitor::NotifyConnectionTypeChanged( void AndroidNetworkMonitor::NotifyConnectionTypeChanged(
JNIEnv* env, JNIEnv* env,
const JavaRef<jobject>& j_caller) { const JavaRef<jobject>& j_caller) {
network_thread_->PostTask(ToQueuedTask(safety_flag_, [this] { network_thread_->PostTask(SafeTask(safety_flag_, [this] {
RTC_LOG(LS_INFO) RTC_LOG(LS_INFO)
<< "Android network monitor detected connection type change."; << "Android network monitor detected connection type change.";
InvokeNetworksChangedCallback(); InvokeNetworksChangedCallback();
@ -654,8 +653,8 @@ void AndroidNetworkMonitor::NotifyOfNetworkConnect(
const JavaRef<jobject>& j_network_info) { const JavaRef<jobject>& j_network_info) {
NetworkInformation network_info = NetworkInformation network_info =
GetNetworkInformationFromJava(env, j_network_info); GetNetworkInformationFromJava(env, j_network_info);
network_thread_->PostTask(ToQueuedTask( network_thread_->PostTask(
safety_flag_, [this, network_info = std::move(network_info)] { SafeTask(safety_flag_, [this, network_info = std::move(network_info)] {
OnNetworkConnected_n(network_info); OnNetworkConnected_n(network_info);
})); }));
} }
@ -664,7 +663,7 @@ void AndroidNetworkMonitor::NotifyOfNetworkDisconnect(
JNIEnv* env, JNIEnv* env,
const JavaRef<jobject>& j_caller, const JavaRef<jobject>& j_caller,
jlong network_handle) { jlong network_handle) {
network_thread_->PostTask(ToQueuedTask(safety_flag_, [this, network_handle] { network_thread_->PostTask(SafeTask(safety_flag_, [this, network_handle] {
OnNetworkDisconnected_n(static_cast<NetworkHandle>(network_handle)); OnNetworkDisconnected_n(static_cast<NetworkHandle>(network_handle));
})); }));
} }
@ -678,9 +677,9 @@ void AndroidNetworkMonitor::NotifyOfNetworkPreference(
rtc::NetworkPreference preference = rtc::NetworkPreference preference =
static_cast<rtc::NetworkPreference>(jpreference); static_cast<rtc::NetworkPreference>(jpreference);
network_thread_->PostTask(ToQueuedTask( network_thread_->PostTask(SafeTask(safety_flag_, [this, type, preference] {
safety_flag_, OnNetworkPreference_n(type, preference);
[this, type, preference] { OnNetworkPreference_n(type, preference); })); }));
} }
} // namespace jni } // namespace jni

1
sdk/android/src/jni/video_encoder_wrapper.cc
View File

@ -12,7 +12,6 @@
#include <utility> #include <utility>
#include "api/task_queue/to_queued_task.h"
#include "common_video/h264/h264_common.h" #include "common_video/h264/h264_common.h"
#include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/include/video_codec_interface.h"
#include "modules/video_coding/include/video_error_codes.h" #include "modules/video_coding/include/video_error_codes.h"

4
sdk/objc/native/src/objc_network_monitor.mm
View File

@ -11,8 +11,6 @@
#include "sdk/objc/native/src/objc_network_monitor.h" #include "sdk/objc/native/src/objc_network_monitor.h"
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "api/task_queue/to_queued_task.h"
#include <algorithm> #include <algorithm>
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
@ -87,7 +85,7 @@ rtc::NetworkMonitorInterface::InterfaceInfo ObjCNetworkMonitor::GetInterfaceInfo
void ObjCNetworkMonitor::OnPathUpdate( void ObjCNetworkMonitor::OnPathUpdate(
std::map<std::string, rtc::AdapterType, rtc::AbslStringViewCmp> adapter_type_by_name) { std::map<std::string, rtc::AdapterType, rtc::AbslStringViewCmp> adapter_type_by_name) {
RTC_DCHECK(network_monitor_ != nil); RTC_DCHECK(network_monitor_ != nil);
thread_->PostTask(ToQueuedTask(safety_flag_, [this, adapter_type_by_name] { thread_->PostTask(SafeTask(safety_flag_, [this, adapter_type_by_name] {
RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK_RUN_ON(thread_);
adapter_type_by_name_ = adapter_type_by_name; adapter_type_by_name_ = adapter_type_by_name;
InvokeNetworksChangedCallback(); InvokeNetworksChangedCallback();

1
video/video_stream_decoder_impl.cc
View File

@ -12,7 +12,6 @@
#include <memory> #include <memory>
#include "api/task_queue/queued_task.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/numerics/mod_ops.h" #include "rtc_base/numerics/mod_ops.h"
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"

1
video/video_stream_encoder.cc
View File

@ -22,7 +22,6 @@
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/field_trials_view.h" #include "api/field_trials_view.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/queued_task.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/video/encoded_image.h" #include "api/video/encoded_image.h"
#include "api/video/i420_buffer.h" #include "api/video/i420_buffer.h"