Add ability to specify delayed task precision in RepeatingTaskHandle.
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}
diff --git a/rtc_base/task_utils/repeating_task_unittest.cc b/rtc_base/task_utils/repeating_task_unittest.cc
index 1d26ee6..d6ab920 100644
--- a/rtc_base/task_utils/repeating_task_unittest.cc
+++ b/rtc_base/task_utils/repeating_task_unittest.cc
@@ -64,12 +64,22 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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