mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
91eab23eb3
Switches the Windows embedding from the standard C API to the new proctable version, to allow for unit testing of the embedding layer separately from the embedder APIs implementation. This includes moving some engine messaging that was still in flutter_windows to the C++ engine class to better encapsulate the proc table.
103 lines
3.4 KiB
C++
103 lines
3.4 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.
|
|
|
|
#include "flutter/shell/platform/windows/win32_task_runner.h"
|
|
|
|
#include <atomic>
|
|
#include <iostream>
|
|
#include <utility>
|
|
|
|
namespace flutter {
|
|
|
|
Win32TaskRunner::Win32TaskRunner(DWORD main_thread_id,
|
|
CurrentTimeProc get_current_time,
|
|
const TaskExpiredCallback& on_task_expired)
|
|
: main_thread_id_(main_thread_id),
|
|
get_current_time_(get_current_time),
|
|
on_task_expired_(std::move(on_task_expired)) {}
|
|
|
|
Win32TaskRunner::~Win32TaskRunner() = default;
|
|
|
|
bool Win32TaskRunner::RunsTasksOnCurrentThread() const {
|
|
return GetCurrentThreadId() == main_thread_id_;
|
|
}
|
|
|
|
std::chrono::nanoseconds Win32TaskRunner::ProcessTasks() {
|
|
const TaskTimePoint 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 = task_queue_.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) {
|
|
break;
|
|
}
|
|
|
|
// 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.
|
|
expired_tasks.push_back(task_queue_.top().task);
|
|
|
|
// Remove the tasks from the delayed tasks queue.
|
|
task_queue_.pop();
|
|
}
|
|
}
|
|
|
|
// Fire expired tasks.
|
|
{
|
|
// Flushing tasks here without holing onto the task queue mutex.
|
|
for (const auto& task : expired_tasks) {
|
|
on_task_expired_(&task);
|
|
}
|
|
}
|
|
|
|
// Calculate duration to sleep for on next iteration.
|
|
{
|
|
std::lock_guard<std::mutex> lock(task_queue_mutex_);
|
|
const auto next_wake = task_queue_.empty() ? TaskTimePoint::max()
|
|
: task_queue_.top().fire_time;
|
|
|
|
return std::min(next_wake - now, std::chrono::nanoseconds::max());
|
|
}
|
|
}
|
|
|
|
Win32TaskRunner::TaskTimePoint Win32TaskRunner::TimePointFromFlutterTime(
|
|
uint64_t flutter_target_time_nanos) const {
|
|
const auto now = TaskTimePoint::clock::now();
|
|
const auto flutter_duration = flutter_target_time_nanos - get_current_time_();
|
|
return now + std::chrono::nanoseconds(flutter_duration);
|
|
}
|
|
|
|
void Win32TaskRunner::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_);
|
|
task_queue_.push(task);
|
|
|
|
// 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.
|
|
}
|
|
|
|
if (!PostThreadMessage(main_thread_id_, WM_NULL, 0, 0)) {
|
|
std::cerr << "Failed to post message to main thread." << std::endl;
|
|
}
|
|
}
|
|
|
|
} // namespace flutter
|