zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add ability to specify delayed task precision in RepeatingTaskHandle.

Browse Source 
See go/postdelayedtask-precision-in-webrtc for context of which use
cases are considered "high" or "low". Most use cases are "low" which
is the default, but this CL allows opting in to "high".

Will be used by FrameBuffer2.

Bug: webrtc:13604
Change-Id: Iebf6eea44779873e78746da749a39e1101b92819
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/248861
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35776}
This commit is contained in:
Henrik Boström
2022-01-24 17:12:35 +01:00
committed by WebRTC LUCI CQ
parent 6f542d5e92
commit 27e8a095bf
4 changed files with 125 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
rtc_base/task_utils/repeating_task_unittest.cc
View File

@ -64,12 +64,22 @@ class FakeTaskQueue : public TaskQueueBase {
void Delete() override {}
void PostTask(std::unique_ptr<QueuedTask> task) override {
PostDelayedTask(std::move(task), 0);
last_task_ = std::move(task);
last_precision_ = absl::nullopt;
last_delay_ = 0;
}
void PostDelayedTask(std::unique_ptr<QueuedTask> task,
uint32_t milliseconds) override {
last_task_ = std::move(task);
last_precision_ = TaskQueueBase::DelayPrecision::kLow;
last_delay_ = milliseconds;
}
void PostDelayedHighPrecisionTask(std::unique_ptr<QueuedTask> task,
uint32_t milliseconds) override {
last_task_ = std::move(task);
last_precision_ = TaskQueueBase::DelayPrecision::kHigh;
last_delay_ = milliseconds;
}
@ -94,11 +104,16 @@ class FakeTaskQueue : public TaskQueueBase {
return last_delay_.value_or(-1);
}
absl::optional<TaskQueueBase::DelayPrecision> last_precision() const {
return last_precision_;
}
private:
CurrentTaskQueueSetter task_queue_setter_;
SimulatedClock* clock_;
std::unique_ptr<QueuedTask> last_task_;
absl::optional<uint32_t> last_delay_;
absl::optional<TaskQueueBase::DelayPrecision> last_precision_;
};
// NOTE: Since this utility class holds a raw pointer to a variable that likely
@ -165,7 +180,7 @@ TEST(RepeatingTaskTest, CompensatesForLongRunTime) {
clock.AdvanceTime(kSleepDuration);
return kRepeatInterval;
},
&clock);
TaskQueueBase::DelayPrecision::kLow, &clock);
EXPECT_EQ(task_queue.last_delay(), 0u);
EXPECT_FALSE(task_queue.AdvanceTimeAndRunLastTask());
@ -188,7 +203,7 @@ TEST(RepeatingTaskTest, CompensatesForShortRunTime) {
clock.AdvanceTime(TimeDelta::Millis(100));
return TimeDelta::Millis(300);
},
&clock);
TaskQueueBase::DelayPrecision::kLow, &clock);
// Expect instant post task.
EXPECT_EQ(task_queue.last_delay(), 0u);
@ -338,7 +353,7 @@ TEST(RepeatingTaskTest, ClockIntegration) {
clock.AdvanceTimeMilliseconds(10);
return TimeDelta::Millis(100);
},
&clock);
TaskQueueBase::DelayPrecision::kLow, &clock);
clock.AdvanceTimeMilliseconds(100);
QueuedTask* task_to_run = delayed_task.release();
@ -366,4 +381,66 @@ TEST(RepeatingTaskTest, CanBeStoppedAfterTaskQueueDeletedTheRepeatingTask) {
handle.Stop();
}
TEST(RepeatingTaskTest, DefaultPrecisionIsLow) {
SimulatedClock clock(Timestamp::Zero());
FakeTaskQueue task_queue(&clock);
// Closure that repeats twice.
MockFunction<TimeDelta()> closure;
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Millis(1)))
.WillOnce(Return(TimeDelta::PlusInfinity()));
RepeatingTaskHandle::Start(&task_queue, closure.AsStdFunction());
// Initial task is a PostTask().
EXPECT_FALSE(task_queue.last_precision().has_value());
EXPECT_FALSE(task_queue.AdvanceTimeAndRunLastTask());
// Repeated task is a delayed task with the default precision: low.
EXPECT_TRUE(task_queue.last_precision().has_value());
EXPECT_EQ(task_queue.last_precision().value(),
TaskQueueBase::DelayPrecision::kLow);
// No more tasks.
EXPECT_TRUE(task_queue.AdvanceTimeAndRunLastTask());
}
TEST(RepeatingTaskTest, CanSpecifyToPostTasksWithLowPrecision) {
SimulatedClock clock(Timestamp::Zero());
FakeTaskQueue task_queue(&clock);
// Closure that repeats twice.
MockFunction<TimeDelta()> closure;
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Millis(1)))
.WillOnce(Return(TimeDelta::PlusInfinity()));
RepeatingTaskHandle::Start(&task_queue, closure.AsStdFunction(),
TaskQueueBase::DelayPrecision::kLow);
// Initial task is a PostTask().
EXPECT_FALSE(task_queue.last_precision().has_value());
EXPECT_FALSE(task_queue.AdvanceTimeAndRunLastTask());
// Repeated task is a delayed task with the specified precision.
EXPECT_TRUE(task_queue.last_precision().has_value());
EXPECT_EQ(task_queue.last_precision().value(),
TaskQueueBase::DelayPrecision::kLow);
// No more tasks.
EXPECT_TRUE(task_queue.AdvanceTimeAndRunLastTask());
}
TEST(RepeatingTaskTest, CanSpecifyToPostTasksWithHighPrecision) {
SimulatedClock clock(Timestamp::Zero());
FakeTaskQueue task_queue(&clock);
// Closure that repeats twice.
MockFunction<TimeDelta()> closure;
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Millis(1)))
.WillOnce(Return(TimeDelta::PlusInfinity()));
RepeatingTaskHandle::Start(&task_queue, closure.AsStdFunction(),
TaskQueueBase::DelayPrecision::kHigh);
// Initial task is a PostTask().
EXPECT_FALSE(task_queue.last_precision().has_value());
EXPECT_FALSE(task_queue.AdvanceTimeAndRunLastTask());
// Repeated task is a delayed task with the specified precision.
EXPECT_TRUE(task_queue.last_precision().has_value());
EXPECT_EQ(task_queue.last_precision().value(),
TaskQueueBase::DelayPrecision::kHigh);
// No more tasks.
EXPECT_TRUE(task_queue.AdvanceTimeAndRunLastTask());
}
} // namespace webrtc