blob: a5dc89f8ac9cbb6dfc391665d26030c8906b3721 [file] [log] [blame]
// 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.
#include "flutter/shell/platform/glfw/event_loop.h"
#include <atomic>
#include <utility>
namespace flutter {
EventLoop::EventLoop(std::thread::id main_thread_id,
const TaskExpiredCallback& on_task_expired)
: main_thread_id_(main_thread_id),
on_task_expired_(std::move(on_task_expired)) {}
EventLoop::~EventLoop() = default;
bool EventLoop::RunsTasksOnCurrentThread() const {
return std::this_thread::get_id() == main_thread_id_;
void EventLoop::WaitForEvents(std::chrono::nanoseconds max_wait) {
const auto now = TaskTimePoint::clock::now();
std::vector<FlutterTask> expired_tasks;
// Process expired tasks.
std::lock_guard<std::mutex> lock(task_queue_mutex_);
while (!task_queue_.empty()) {
const auto& top =;
// If this task (and all tasks after this) has not yet expired, there is
// nothing more to do. Quit iterating.
if (top.fire_time > now) {
// Make a record of the expired task. Do NOT service the task here
// because we are still holding onto the task queue mutex. We don't want
// other threads to block on posting tasks onto this thread till we are
// done processing expired tasks.
// Remove the tasks from the delayed tasks queue.
// Fire expired tasks.
// Flushing tasks here without holing onto the task queue mutex.
for (const auto& task : expired_tasks) {
// Sleep till the next task needs to be processed. If a new task comes
// along, the wait will be resolved early because PostTask calls Wake().
TaskTimePoint next_wake;
std::lock_guard<std::mutex> lock(task_queue_mutex_);
TaskTimePoint max_wake_timepoint =
max_wait == std::chrono::nanoseconds::max() ? TaskTimePoint::max()
: now + max_wait;
TaskTimePoint next_event_timepoint = task_queue_.empty()
? TaskTimePoint::max()
next_wake = std::min(max_wake_timepoint, next_event_timepoint);
EventLoop::TaskTimePoint EventLoop::TimePointFromFlutterTime(
uint64_t flutter_target_time_nanos) {
const auto now = TaskTimePoint::clock::now();
const int64_t flutter_duration =
flutter_target_time_nanos - FlutterEngineGetCurrentTime();
return now + std::chrono::nanoseconds(flutter_duration);
void EventLoop::PostTask(FlutterTask flutter_task,
uint64_t flutter_target_time_nanos) {
static std::atomic_uint64_t sGlobalTaskOrder(0);
Task task;
task.order = ++sGlobalTaskOrder;
task.fire_time = TimePointFromFlutterTime(flutter_target_time_nanos);
task.task = flutter_task;
std::lock_guard<std::mutex> lock(task_queue_mutex_);
// Make sure the queue mutex is unlocked before waking up the loop. In case
// the wake causes this thread to be descheduled for the primary thread to
// process tasks, the acquisition of the lock on that thread while holding
// the lock here momentarily till the end of the scope is a pessimization.
} // namespace flutter