[Linux] Move rendering to raster thread

knopp · knopp · commit e04098a36c69 · 2025-02-04T13:19:07.000+01:00
diff --git a/engine/src/flutter/shell/platform/linux/fl_engine.cc b/engine/src/flutter/shell/platform/linux/fl_engine.cc
@@ -354,7 +354,7 @@ static void fl_engine_post_task(FlutterTask task,
                                 void* user_data) {
   FlEngine* self = static_cast<FlEngine*>(user_data);
 
-  fl_task_runner_post_task(self->task_runner, task, target_time_nanos);
+  fl_task_runner_post_flutter_task(self->task_runner, task, target_time_nanos);
 }
 
 // Called when a platform message is received from the engine.
@@ -597,7 +597,6 @@ gboolean fl_engine_start(FlEngine* self, GError** error) {
   FlutterCustomTaskRunners custom_task_runners = {};
   custom_task_runners.struct_size = sizeof(FlutterCustomTaskRunners);
   custom_task_runners.platform_task_runner = &platform_task_runner;
-  custom_task_runners.render_task_runner = &platform_task_runner;
 
   g_autoptr(GPtrArray) command_line_args =
       g_ptr_array_new_with_free_func(g_free);
diff --git a/engine/src/flutter/shell/platform/linux/fl_renderer.cc b/engine/src/flutter/shell/platform/linux/fl_renderer.cc
@@ -73,6 +73,11 @@ typedef struct {
 
   // Framebuffers to render keyed by view ID.
   GHashTable* framebuffers_by_view_id;
+
+  // Mutex and condition used when block the raster thread until a task
+  // is completed on platform thread.
+  GMutex mutex;
+  GCond cond;
 } FlRendererPrivate;
 
 G_DEFINE_TYPE_WITH_PRIVATE(FlRenderer, fl_renderer, G_TYPE_OBJECT)
@@ -313,10 +318,32 @@ static void fl_renderer_dispose(GObject* object) {
   g_clear_pointer(&priv->framebuffers_by_view_id, g_hash_table_unref);
 
   G_OBJECT_CLASS(fl_renderer_parent_class)->dispose(object);
+
+  g_mutex_clear(&priv->mutex);
+  g_cond_clear(&priv->cond);
+}
+
+static gboolean fl_renderer_schedule_on_main_thread(
+    FlRenderer* self,
+    void (*callback)(gpointer data),
+    gpointer callback_data) {
+  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
+      fl_renderer_get_instance_private(self));
+  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&priv->engine));
+
+  if (engine == nullptr) {
+    return FALSE;
+  }
+
+  FlTaskRunner* task_runner = fl_engine_get_task_runner(engine);
+  fl_task_runner_post_callback(task_runner, callback, callback_data);
+  return TRUE;
 }
 
 static void fl_renderer_class_init(FlRendererClass* klass) {
   G_OBJECT_CLASS(klass)->dispose = fl_renderer_dispose;
+  FL_RENDERER_CLASS(klass)->schedule_on_main_thread =
+      fl_renderer_schedule_on_main_thread;
 }
 
 static void fl_renderer_init(FlRenderer* self) {
@@ -327,6 +354,8 @@ static void fl_renderer_init(FlRenderer* self) {
   priv->framebuffers_by_view_id = g_hash_table_new_full(
       g_direct_hash, g_direct_equal, nullptr,
       reinterpret_cast<GDestroyNotify>(g_ptr_array_unref));
+  g_mutex_init(&priv->mutex);
+  g_cond_init(&priv->cond);
 }
 
 void fl_renderer_set_engine(FlRenderer* self, FlEngine* engine) {
@@ -388,6 +417,53 @@ guint32 fl_renderer_get_fbo(FlRenderer* self) {
   return 0;
 }
 
+struct _FlRendererCallBlockingTrampolineData {
+  FlRenderer* renderer;
+  gboolean* finished;
+  void (*callback)(gpointer data);
+  gpointer data;
+};
+
+static void fl_renderer_call_blocking_trampoline(gpointer user_data) {
+  auto* data = static_cast<_FlRendererCallBlockingTrampolineData*>(user_data);
+  data->callback(data->data);
+  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
+      fl_renderer_get_instance_private(data->renderer));
+  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&priv->mutex);
+  *data->finished = TRUE;
+  g_cond_signal(&priv->cond);
+}
+
+// Executes the given function on the main thread and blocks until it completes.
+static void fl_renderer_call_blocking(FlRenderer* self,
+                                      void (*callback)(gpointer data),
+                                      gpointer callback_data) {
+  gboolean finished = FALSE;
+  _FlRendererCallBlockingTrampolineData trampoline_data = {
+      self,
+      &finished,
+      callback,
+      callback_data,
+  };
+
+  gboolean scheduled = FL_RENDERER_GET_CLASS(self)->schedule_on_main_thread(
+      self, fl_renderer_call_blocking_trampoline, &trampoline_data);
+
+  // Don't block if the task was not sucessfully scheduled.
+  if (!scheduled) {
+    return;
+  }
+
+  // Wait for the task to complete.
+  FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
+      fl_renderer_get_instance_private(self));
+
+  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&priv->mutex);
+  while (!finished) {
+    g_cond_wait(&priv->cond, &priv->mutex);
+  }
+}
+
 gboolean fl_renderer_create_backing_store(
     FlRenderer* self,
     const FlutterBackingStoreConfig* config,
@@ -450,10 +526,11 @@ void fl_renderer_wait_for_frame(FlRenderer* self,
   }
 }
 
-gboolean fl_renderer_present_layers(FlRenderer* self,
-                                    FlutterViewId view_id,
-                                    const FlutterLayer** layers,
-                                    size_t layers_count) {
+static gboolean fl_renderer_present_layers_on_main_thread(
+    FlRenderer* self,
+    FlutterViewId view_id,
+    const FlutterLayer** layers,
+    size_t layers_count) {
   FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
       fl_renderer_get_instance_private(self));
 
@@ -564,6 +641,41 @@ gboolean fl_renderer_present_layers(FlRenderer* self,
   return TRUE;
 }
 
+struct _FlRendererPresentLayersData {
+  FlRenderer* self;
+  FlutterViewId view_id;
+  const FlutterLayer** layers;
+  size_t layers_count;
+  gboolean* res;
+};
+
+static void fl_renderer_present_layers_trampoline(gpointer trampoline_data) {
+  _FlRendererPresentLayersData* data =
+      reinterpret_cast<_FlRendererPresentLayersData*>(trampoline_data);
+  fl_renderer_make_current(data->self);
+  *data->res = fl_renderer_present_layers_on_main_thread(
+      data->self, data->view_id, data->layers, data->layers_count);
+  fl_renderer_clear_current(data->self);
+}
+
+gboolean fl_renderer_present_layers(FlRenderer* self,
+                                    FlutterViewId view_id,
+                                    const FlutterLayer** layers,
+                                    size_t layers_count) {
+  gboolean res = FALSE;
+  _FlRendererPresentLayersData data = {
+      .self = self,
+      .view_id = view_id,
+      .layers = layers,
+      .layers_count = layers_count,
+      .res = &res,
+  };
+  fl_renderer_clear_current(self);
+  fl_renderer_call_blocking(self, fl_renderer_present_layers_trampoline, &data);
+  fl_renderer_make_current(self);
+  return res;
+}
+
 void fl_renderer_setup(FlRenderer* self) {
   FlRendererPrivate* priv = reinterpret_cast<FlRendererPrivate*>(
       fl_renderer_get_instance_private(self));
diff --git a/engine/src/flutter/shell/platform/linux/fl_renderer.h b/engine/src/flutter/shell/platform/linux/fl_renderer.h
@@ -55,6 +55,14 @@ struct _FlRendererClass {
    * @renderer: an #FlRenderer.
    */
   void (*clear_current)(FlRenderer* renderer);
+
+  /**
+   * Virtual method responsible for scheduling the callback on the main thread.
+   * Overriden in the mock renderer.
+   */
+  gboolean (*schedule_on_main_thread)(FlRenderer* renderer,
+                                      void (*callback)(gpointer data),
+                                      gpointer data);
 };
 
 /**
diff --git a/engine/src/flutter/shell/platform/linux/fl_task_runner.cc b/engine/src/flutter/shell/platform/linux/fl_task_runner.cc
@@ -22,9 +22,16 @@ struct _FlTaskRunner {
 };
 
 typedef struct _FlTaskRunnerTask {
-  // absolute time of task (based on g_get_monotonic_time)
+  // absolute time of task (based on g_get_monotonic_time).
   gint64 task_time_micros;
+
+  // flutter task to execute if schedule through
+  // fl_task_runner_post_flutter_task.
   FlutterTask task;
+
+  // callback to execute if scheduled through fl_task_runner_post_callback.
+  void (*callback)(gpointer data);
+  gpointer callback_data;
 } FlTaskRunnerTask;
 
 G_DEFINE_TYPE(FlTaskRunner, fl_task_runner, G_TYPE_OBJECT)
@@ -56,7 +63,11 @@ static void fl_task_runner_process_expired_tasks_locked(FlTaskRunner* self) {
     l = expired_tasks;
     while (l != nullptr) {
       FlTaskRunnerTask* task = static_cast<FlTaskRunnerTask*>(l->data);
-      fl_engine_execute_task(engine, &task->task);
+      if (task->callback != nullptr) {
+        task->callback(task->callback_data);
+      } else {
+        fl_engine_execute_task(engine, &task->task);
+      }
       l = l->next;
     }
   }
@@ -158,9 +169,9 @@ FlTaskRunner* fl_task_runner_new(FlEngine* engine) {
   return self;
 }
 
-void fl_task_runner_post_task(FlTaskRunner* self,
-                              FlutterTask task,
-                              uint64_t target_time_nanos) {
+void fl_task_runner_post_flutter_task(FlTaskRunner* self,
+                                      FlutterTask task,
+                                      uint64_t target_time_nanos) {
   g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
   (void)locker;  // unused variable
 
@@ -173,6 +184,20 @@ void fl_task_runner_post_task(FlTaskRunner* self,
   fl_task_runner_tasks_did_change_locked(self);
 }
 
+void fl_task_runner_post_callback(FlTaskRunner* self,
+                                  void (*callback)(gpointer data),
+                                  gpointer data) {
+  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
+  (void)locker;  // unused variable
+
+  FlTaskRunnerTask* runner_task = g_new0(FlTaskRunnerTask, 1);
+  runner_task->callback = callback;
+  runner_task->callback_data = data;
+
+  self->pending_tasks = g_list_append(self->pending_tasks, runner_task);
+  fl_task_runner_tasks_did_change_locked(self);
+}
+
 void fl_task_runner_block_main_thread(FlTaskRunner* self) {
   g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
   (void)locker;  // unused variable
diff --git a/engine/src/flutter/shell/platform/linux/fl_task_runner.h b/engine/src/flutter/shell/platform/linux/fl_task_runner.h
@@ -25,17 +25,29 @@ G_DECLARE_FINAL_TYPE(FlTaskRunner, fl_task_runner, FL, TASK_RUNNER, GObject);
 FlTaskRunner* fl_task_runner_new(FlEngine* engine);
 
 /**
- * fl_task_runner_post_task:
+ * fl_task_runner_post_flutter_task:
  * @task_runner: an #FlTaskRunner.
  * @task: Flutter task being scheduled
  * @target_time_nanos: absolute time in nanoseconds
  *
  * Posts a Flutter task to be executed on main thread. This function is thread
  * safe and may be called from any thread.
  */
-void fl_task_runner_post_task(FlTaskRunner* task_runner,
-                              FlutterTask task,
-                              uint64_t target_time_nanos);
+void fl_task_runner_post_flutter_task(FlTaskRunner* task_runner,
+                                      FlutterTask task,
+                                      uint64_t target_time_nanos);
+
+/**
+ * fl_task_runner_post_callback:
+ * @task_runner: an #FlTaskRunner.
+ * @callback: callback to be scheduled
+ * @data: data to be passed to the callback
+ *
+ * Schedules arbitrary callback to be executed on main thread.
+ */
+void fl_task_runner_post_callback(FlTaskRunner* task_runner,
+                                  void (*callback)(gpointer data),
+                                  gpointer data);
 
 /**
  * fl_task_runner_block_main_thread:
diff --git a/engine/src/flutter/shell/platform/linux/fl_view.cc b/engine/src/flutter/shell/platform/linux/fl_view.cc
@@ -530,6 +530,10 @@ static void realize_cb(FlView* self) {
   fl_renderer_add_renderable(FL_RENDERER(self->renderer), self->view_id,
                              FL_RENDERABLE(self));
 
+  // Flutter engine will need to make the context current from raster thread
+  // during initialization.
+  fl_renderer_clear_current(FL_RENDERER(self->renderer));
+
   if (!fl_engine_start(self->engine, &error)) {
     g_warning("Failed to start Flutter engine: %s", error->message);
     return;
diff --git a/engine/src/flutter/shell/platform/linux/testing/mock_renderer.cc b/engine/src/flutter/shell/platform/linux/testing/mock_renderer.cc
@@ -29,6 +29,15 @@ static void fl_mock_renderer_make_current(FlRenderer* renderer) {}
 // Implements FlRenderer::make_resource_current.
 static void fl_mock_renderer_make_resource_current(FlRenderer* renderer) {}
 
+// Implements FlRenderer::schedule_on_main_thread.
+static gboolean fl_mock_renderer_schedule_on_main_thread(
+    FlRenderer* renderer,
+    void (*callback)(gpointer data),
+    gpointer data) {
+  callback(data);
+  return TRUE;
+}
+
 // Implements FlRenderer::clear_current.
 static void fl_mock_renderer_clear_current(FlRenderer* renderer) {}
 
@@ -37,6 +46,8 @@ static void fl_mock_renderer_class_init(FlMockRendererClass* klass) {
   FL_RENDERER_CLASS(klass)->make_resource_current =
       fl_mock_renderer_make_resource_current;
   FL_RENDERER_CLASS(klass)->clear_current = fl_mock_renderer_clear_current;
+  FL_RENDERER_CLASS(klass)->schedule_on_main_thread =
+      fl_mock_renderer_schedule_on_main_thread;
 }
 
 static void fl_mock_renderer_init(FlMockRenderer* self) {}
