mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Implement support for Chrome task origin tracing. #3.5/4

Browse source 
This CL migrates unit tests to the new TaskQueueBase interface.

Bug: chromium:1416199
Change-Id: Ic15c694b28eb67450ac99fdd56754de1246a4d95
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/295621
Commit-Queue: Markus Handell <handellm@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39434}
This commit is contained in:
Markus Handell 2023-03-01 10:13:28 +01:00 committed by WebRTC LUCI CQ
parent f6afb3fd57
commit a1ceae206b
14 changed files with 129 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
api/task_queue/test/mock_task_queue_base.h
View file

@ -20,15 +20,22 @@ namespace webrtc {
class MockTaskQueueBase : public TaskQueueBase {
public:
using TaskQueueBase::PostDelayedTaskTraits;
using TaskQueueBase::PostTaskTraits;
MOCK_METHOD(void, Delete, (), (override));
MOCK_METHOD(void, PostTask, (absl::AnyInvocable<void() &&>), (override));
MOCK_METHOD(void,
PostDelayedTask,
(absl::AnyInvocable<void() &&>, TimeDelta),
PostTaskImpl,
(absl::AnyInvocable<void() &&>,
const PostTaskTraits&,
const Location&),
(override));
MOCK_METHOD(void,
PostDelayedHighPrecisionTask,
(absl::AnyInvocable<void() &&>, TimeDelta),
PostDelayedTaskImpl,
(absl::AnyInvocable<void() &&>,
TimeDelta,
const PostDelayedTaskTraits&,
const Location&),
(override));
};

4
audio/audio_state_unittest.cc
View file

@ -40,7 +40,9 @@ struct FakeAsyncAudioProcessingHelper {
FakeTaskQueue() = default;
void Delete() override { delete this; }
void PostTask(absl::AnyInvocable<void() &&> task) override {
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& /*traits*/,
const Location& /*location*/) override {
std::move(task)();
}
};

8
audio/voip/test/audio_channel_unittest.cc
View file

@ -14,6 +14,7 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/call/transport.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "audio/voip/test/mock_task_queue.h"
#include "modules/audio_mixer/audio_mixer_impl.h"
@ -31,6 +32,7 @@ using ::testing::Invoke;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::Unused;
using ::testing::WithArg;
constexpr uint64_t kStartTime = 123456789;
constexpr uint32_t kLocalSsrc = 0xdeadc0de;
@ -49,9 +51,9 @@ class AudioChannelTest : public ::testing::Test {
decoder_factory_ = CreateBuiltinAudioDecoderFactory();
// By default, run the queued task immediately.
ON_CALL(task_queue_, PostTask)
.WillByDefault(
[](absl::AnyInvocable<void() &&> task) { std::move(task)(); });
ON_CALL(task_queue_, PostTaskImpl)
.WillByDefault(WithArg<0>(
[](absl::AnyInvocable<void() &&> task) { std::move(task)(); }));
}
void SetUp() override { audio_channel_ = CreateAudioChannel(kLocalSsrc); }

28
net/dcsctp/timer/task_queue_timeout_test.cc
View file

@ -20,6 +20,7 @@
namespace dcsctp {
namespace {
using ::testing::_;
using ::testing::Field;
using ::testing::MockFunction;
using ::testing::NiceMock;
@ -118,7 +119,14 @@ TEST_F(TaskQueueTimeoutTest, KilledBeforeExpired) {
TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToLow) {
NiceMock<webrtc::MockTaskQueueBase> mock_task_queue;
EXPECT_CALL(mock_task_queue, PostDelayedTask(_, _));
EXPECT_CALL(
mock_task_queue,
PostDelayedTaskImpl(
_, _,
Field(
&webrtc::MockTaskQueueBase::PostDelayedTaskTraits::high_precision,
false),
_));
TaskQueueTimeoutFactory factory(
mock_task_queue, []() { return TimeMs(1337); },
[](TimeoutID timeout_id) {});
@ -129,7 +137,14 @@ TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToLow) {
TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToHigh) {
NiceMock<webrtc::MockTaskQueueBase> mock_task_queue;
EXPECT_CALL(mock_task_queue, PostDelayedHighPrecisionTask(_, _));
EXPECT_CALL(
mock_task_queue,
PostDelayedTaskImpl(
_, _,
Field(
&webrtc::MockTaskQueueBase::PostDelayedTaskTraits::high_precision,
true),
_));
TaskQueueTimeoutFactory factory(
mock_task_queue, []() { return TimeMs(1337); },
[](TimeoutID timeout_id) {});
@ -140,7 +155,14 @@ TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToHigh) {
TEST(TaskQueueTimeoutWithMockTaskQueueTest, TimeoutPrecisionIsLowByDefault) {
NiceMock<webrtc::MockTaskQueueBase> mock_task_queue;
EXPECT_CALL(mock_task_queue, PostDelayedTask(_, _));
EXPECT_CALL(
mock_task_queue,
PostDelayedTaskImpl(
_, _,
Field(
&webrtc::MockTaskQueueBase::PostDelayedTaskTraits::high_precision,
false),
_));
TaskQueueTimeoutFactory factory(
mock_task_queue, []() { return TimeMs(1337); },
[](TimeoutID timeout_id) {});

1
rtc_base/task_utils/BUILD.gn
View file

@ -36,6 +36,7 @@ if (rtc_include_tests) {
"..:rtc_task_queue",
"..:task_queue_for_test",
"../../api/task_queue",
"../../api/task_queue/test:mock_task_queue_base",
"../../api/units:time_delta",
"../../api/units:timestamp",
"../../system_wrappers:system_wrappers",

48
rtc_base/task_utils/repeating_task_unittest.cc
View file

@ -15,6 +15,7 @@
#include "absl/functional/any_invocable.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/test/mock_task_queue_base.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "rtc_base/event.h"
@ -32,6 +33,7 @@ using ::testing::Invoke;
using ::testing::MockFunction;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::WithArg;
constexpr TimeDelta kTimeout = TimeDelta::Millis(1000);
@ -41,21 +43,10 @@ class MockClosure {
MOCK_METHOD(void, Delete, ());
};
class MockTaskQueue : public TaskQueueBase {
class MockTaskQueue : public MockTaskQueueBase {
public:
MockTaskQueue() : task_queue_setter_(this) {}
MOCK_METHOD(void, Delete, (), (override));
MOCK_METHOD(void, PostTask, (absl::AnyInvocable<void() &&>), (override));
MOCK_METHOD(void,
PostDelayedTask,
(absl::AnyInvocable<void() &&>, TimeDelta),
(override));
MOCK_METHOD(void,
PostDelayedHighPrecisionTask,
(absl::AnyInvocable<void() &&>, TimeDelta),
(override));
private:
CurrentTaskQueueSetter task_queue_setter_;
};
@ -67,23 +58,22 @@ class FakeTaskQueue : public TaskQueueBase {
void Delete() override {}
void PostTask(absl::AnyInvocable<void() &&> task) override {
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& /*traits*/,
const Location& /*location*/) override {
last_task_ = std::move(task);
last_precision_ = absl::nullopt;
last_delay_ = TimeDelta::Zero();
}
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override {
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& /*location*/) override {
last_task_ = std::move(task);
last_precision_ = TaskQueueBase::DelayPrecision::kLow;
last_delay_ = delay;
}
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override {
last_task_ = std::move(task);
last_precision_ = TaskQueueBase::DelayPrecision::kHigh;
last_precision_ = traits.high_precision
? TaskQueueBase::DelayPrecision::kHigh
: TaskQueueBase::DelayPrecision::kLow;
last_delay_ = delay;
}
@ -339,8 +329,10 @@ TEST(RepeatingTaskTest, ClockIntegration) {
SimulatedClock clock(Timestamp::Zero());
NiceMock<MockTaskQueue> task_queue;
ON_CALL(task_queue, PostDelayedTask)
.WillByDefault([&](absl::AnyInvocable<void() &&> task, TimeDelta delay) {
ON_CALL(task_queue, PostDelayedTaskImpl)
.WillByDefault([&](absl::AnyInvocable<void() &&> task, TimeDelta delay,
const MockTaskQueue::PostDelayedTaskTraits&,
const Location&) {
EXPECT_EQ(delay, expected_delay);
delayed_task = std::move(task);
});
@ -368,10 +360,10 @@ TEST(RepeatingTaskTest, CanBeStoppedAfterTaskQueueDeletedTheRepeatingTask) {
absl::AnyInvocable<void() &&> repeating_task;
MockTaskQueue task_queue;
EXPECT_CALL(task_queue, PostDelayedTask)
.WillOnce([&](absl::AnyInvocable<void() &&> task, TimeDelta delay) {
EXPECT_CALL(task_queue, PostDelayedTaskImpl)
.WillOnce(WithArg<0>([&](absl::AnyInvocable<void() &&> task) {
repeating_task = std::move(task);
});
}));
RepeatingTaskHandle handle =
RepeatingTaskHandle::DelayedStart(&task_queue, TimeDelta::Millis(100),

12
rtc_base/unique_id_generator_unittest.cc
View file

@ -33,11 +33,13 @@ class FakeTaskQueue : public webrtc::TaskQueueBase {
FakeTaskQueue() : task_queue_setter_(this) {}
void Delete() override {}
void PostTask(absl::AnyInvocable<void() &&> task) override {}
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
webrtc::TimeDelta delay) override {}
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
webrtc::TimeDelta delay) override {}
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const webrtc::Location& location) override {}
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
webrtc::TimeDelta delay,
const PostDelayedTaskTraits& traits,
const webrtc::Location& location) override {}
private:
CurrentTaskQueueSetter task_queue_setter_;

23
test/time_controller/external_time_controller.cc
View file

@ -33,23 +33,24 @@ class ExternalTimeController::TaskQueueWrapper : public TaskQueueBase {
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> base)
: parent_(parent), base_(std::move(base)) {}
void PostTask(absl::AnyInvocable<void() &&> task) override {
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const Location& location) override {
parent_->UpdateTime();
base_->PostTask(TaskWrapper(std::move(task)));
parent_->ScheduleNext();
}
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override {
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& location) override {
parent_->UpdateTime();
base_->PostDelayedTask(TaskWrapper(std::move(task)), delay);
parent_->ScheduleNext();
}
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override {
parent_->UpdateTime();
base_->PostDelayedHighPrecisionTask(TaskWrapper(std::move(task)), delay);
if (traits.high_precision) {
base_->PostDelayedHighPrecisionTask(TaskWrapper(std::move(task)), delay);
} else {
base_->PostDelayedTask(TaskWrapper(std::move(task)), delay);
}
parent_->ScheduleNext();
}

15
test/time_controller/simulated_task_queue.cc
View file

@ -66,20 +66,19 @@ void SimulatedTaskQueue::RunReady(Timestamp at_time) {
}
}
void SimulatedTaskQueue::PostTask(absl::AnyInvocable<void() &&> task) {
void SimulatedTaskQueue::PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& /*traits*/,
const Location& /*location*/) {
MutexLock lock(&lock_);
ready_tasks_.push_back(std::move(task));
next_run_time_ = Timestamp::MinusInfinity();
}
void SimulatedTaskQueue::PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) {
PostDelayedHighPrecisionTask(std::move(task), delay);
}
void SimulatedTaskQueue::PostDelayedHighPrecisionTask(
void SimulatedTaskQueue::PostDelayedTaskImpl(
absl::AnyInvocable<void() &&> task,
TimeDelta delay) {
TimeDelta delay,
const PostDelayedTaskTraits& /*traits*/,
const Location& /*location*/) {
MutexLock lock(&lock_);
Timestamp target_time = handler_->CurrentTime() + delay;
delayed_tasks_[target_time].push_back(std::move(task));

12
test/time_controller/simulated_task_queue.h
View file

@ -40,11 +40,13 @@ class SimulatedTaskQueue : public TaskQueueBase,
// TaskQueueBase interface
void Delete() override;
void PostTask(absl::AnyInvocable<void() &&> task) override;
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override;
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override;
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const Location& location) override;
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& location) override;
private:
sim_time_impl::SimulatedTimeControllerImpl* const handler_;

23
test/time_controller/simulated_thread.cc
View file

@ -77,24 +77,19 @@ void SimulatedThread::BlockingCall(rtc::FunctionView<void()> functor) {
}
}
void SimulatedThread::PostTask(absl::AnyInvocable<void() &&> task) {
rtc::Thread::PostTask(std::move(task));
void SimulatedThread::PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const Location& location) {
rtc::Thread::PostTaskImpl(std::move(task), traits, location);
MutexLock lock(&lock_);
next_run_time_ = Timestamp::MinusInfinity();
}
void SimulatedThread::PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) {
rtc::Thread::PostDelayedTask(std::move(task), delay);
MutexLock lock(&lock_);
next_run_time_ =
std::min(next_run_time_, Timestamp::Millis(rtc::TimeMillis()) + delay);
}
void SimulatedThread::PostDelayedHighPrecisionTask(
absl::AnyInvocable<void() &&> task,
TimeDelta delay) {
rtc::Thread::PostDelayedHighPrecisionTask(std::move(task), delay);
void SimulatedThread::PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& location) {
rtc::Thread::PostDelayedTaskImpl(std::move(task), delay, traits, location);
MutexLock lock(&lock_);
next_run_time_ =
std::min(next_run_time_, Timestamp::Millis(rtc::TimeMillis()) + delay);

12
test/time_controller/simulated_thread.h
View file

@ -37,11 +37,13 @@ class SimulatedThread : public rtc::Thread,
// Thread interface
void BlockingCall(rtc::FunctionView<void()> functor) override;
void PostTask(absl::AnyInvocable<void() &&> task) override;
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override;
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override;
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const Location& location) override;
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& location) override;
void Stop() override;

14
test/time_controller/simulated_time_controller.h
View file

@ -106,15 +106,15 @@ class TokenTaskQueue : public TaskQueueBase {
using CurrentTaskQueueSetter = TaskQueueBase::CurrentTaskQueueSetter;
void Delete() override { RTC_DCHECK_NOTREACHED(); }
void PostTask(absl::AnyInvocable<void() &&> /*task*/) override {
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const Location& location) override {
RTC_DCHECK_NOTREACHED();
}
void PostDelayedTask(absl::AnyInvocable<void() &&> /*task*/,
TimeDelta /*delay*/) override {
RTC_DCHECK_NOTREACHED();
}
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> /*task*/,
TimeDelta /*delay*/) override {
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& location) override {
RTC_DCHECK_NOTREACHED();
}
};

14
video/video_stream_encoder_unittest.cc
View file

@ -9220,15 +9220,15 @@ TEST(VideoStreamEncoderSimpleTest, CreateDestroy) {
private:
void Delete() override { delete this; }
void PostTask(absl::AnyInvocable<void() &&> task) override {
void PostTaskImpl(absl::AnyInvocable<void() &&> task,
const PostTaskTraits& traits,
const Location& location) override {
// meh.
}
void PostDelayedTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override {
ASSERT_TRUE(false);
}
void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
TimeDelta delay) override {
void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
TimeDelta delay,
const PostDelayedTaskTraits& traits,
const Location& location) override {
ADD_FAILURE();
}
};