mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
6f5347c5d6
* Refactor to move Task Queue to its own class - This is to help with sharing task queue among multiple message loops going forward. - currently there is 1:1 mapping between task queue and message loop, we are still maintaining the semantics for this change. * Add mutex include * Most of the waking up changes minus test failures * Refactor MessageLoopImpl to be Wakeable - Makes testing easier by letting us putting a TestWakeable - Also move the waking up logic to the task queue * add tests * Fix formatting and license
136 lines
4.0 KiB
C++
136 lines
4.0 KiB
C++
// Copyright 2013 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#define FML_USED_ON_EMBEDDER
|
|
|
|
#include "flutter/fml/message_loop_task_queue.h"
|
|
#include "flutter/fml/synchronization/count_down_latch.h"
|
|
#include "flutter/fml/synchronization/waitable_event.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
class TestWakeable : public fml::Wakeable {
|
|
public:
|
|
using WakeUpCall = std::function<void(const fml::TimePoint)>;
|
|
|
|
TestWakeable(WakeUpCall call) : wake_up_call_(call) {}
|
|
|
|
void WakeUp(fml::TimePoint time_point) override { wake_up_call_(time_point); }
|
|
|
|
private:
|
|
WakeUpCall wake_up_call_;
|
|
};
|
|
|
|
TEST(MessageLoopTaskQueue, StartsWithNoPendingTasks) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
ASSERT_FALSE(task_queue->HasPendingTasks());
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, RegisterOneTask) {
|
|
const auto time = fml::TimePoint::Max();
|
|
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
task_queue->SetWakeable(new TestWakeable(
|
|
[&time](fml::TimePoint wake_time) { ASSERT_TRUE(wake_time == time); }));
|
|
|
|
task_queue->RegisterTask([] {}, time);
|
|
ASSERT_TRUE(task_queue->HasPendingTasks());
|
|
ASSERT_TRUE(task_queue->GetNumPendingTasks() == 1);
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, RegisterTwoTasksAndCount) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
task_queue->RegisterTask([] {}, fml::TimePoint::Now());
|
|
task_queue->RegisterTask([] {}, fml::TimePoint::Max());
|
|
ASSERT_TRUE(task_queue->HasPendingTasks());
|
|
ASSERT_TRUE(task_queue->GetNumPendingTasks() == 2);
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, PreserveTaskOrdering) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
int test_val = 0;
|
|
|
|
// order: 0
|
|
task_queue->RegisterTask([&test_val]() { test_val = 1; },
|
|
fml::TimePoint::Now());
|
|
|
|
// order: 1
|
|
task_queue->RegisterTask([&test_val]() { test_val = 2; },
|
|
fml::TimePoint::Now());
|
|
|
|
std::vector<fml::closure> invocations;
|
|
task_queue->GetTasksToRunNow(fml::FlushType::kAll, invocations);
|
|
|
|
int expected_value = 1;
|
|
|
|
for (auto& invocation : invocations) {
|
|
invocation();
|
|
ASSERT_TRUE(test_val == expected_value);
|
|
expected_value++;
|
|
}
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, AddRemoveNotifyObservers) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
|
|
int test_val = 0;
|
|
intptr_t key = 123;
|
|
|
|
task_queue->AddTaskObserver(key, [&test_val]() { test_val = 1; });
|
|
task_queue->NotifyObservers();
|
|
ASSERT_TRUE(test_val == 1);
|
|
|
|
test_val = 0;
|
|
task_queue->RemoveTaskObserver(key);
|
|
task_queue->NotifyObservers();
|
|
ASSERT_TRUE(test_val == 0);
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, WakeUpIndependentOfTime) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
|
|
int num_wakes = 0;
|
|
task_queue->SetWakeable(new TestWakeable(
|
|
[&num_wakes](fml::TimePoint wake_time) { ++num_wakes; }));
|
|
|
|
task_queue->RegisterTask([]() {}, fml::TimePoint::Now());
|
|
task_queue->RegisterTask([]() {}, fml::TimePoint::Max());
|
|
|
|
ASSERT_TRUE(num_wakes == 2);
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, WakeUpWithMaxIfNoInvocations) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
fml::AutoResetWaitableEvent ev;
|
|
|
|
task_queue->SetWakeable(new TestWakeable([&ev](fml::TimePoint wake_time) {
|
|
ASSERT_TRUE(wake_time == fml::TimePoint::Max());
|
|
ev.Signal();
|
|
}));
|
|
|
|
std::vector<fml::closure> invocations;
|
|
task_queue->GetTasksToRunNow(fml::FlushType::kAll, invocations);
|
|
ev.Wait();
|
|
}
|
|
|
|
TEST(MessageLoopTaskQueue, WokenUpWithNewerTime) {
|
|
auto task_queue = std::make_unique<fml::MessageLoopTaskQueue>();
|
|
fml::CountDownLatch latch(2);
|
|
|
|
fml::TimePoint expected = fml::TimePoint::Max();
|
|
|
|
task_queue->SetWakeable(
|
|
new TestWakeable([&latch, &expected](fml::TimePoint wake_time) {
|
|
ASSERT_TRUE(wake_time == expected);
|
|
latch.CountDown();
|
|
}));
|
|
|
|
task_queue->RegisterTask([]() {}, fml::TimePoint::Max());
|
|
|
|
const auto now = fml::TimePoint::Now();
|
|
expected = now;
|
|
task_queue->RegisterTask([]() {}, now);
|
|
|
|
latch.Wait();
|
|
}
|