VSync callback support for Linux

This change adds support for VSync callbacks on Linux, making it possible
to run at high refresh rates. The heavy lifting is done by GDK; and so the
implementation just wires the Flutter internals to it.

Unresolved: the implementation conflicts with "smooth resizing" support
(#25884). Smooth resizing blocks the main thread until a frame is rendered,
but this also blocks the VSync callbacks necessary to make progress in
rendering, resulting in a livelock. The smooth resizing is commented out
for now.

Author: ishitatsuyuki

shell/platform/linux/fl_engine.cc

@@ -6,6 +6,7 @@
 
 #include <gmodule.h>
 
+#include <atomic>
 #include <cstring>
 
 #include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
@@ -44,6 +45,9 @@ struct _FlEngine {
   FlEngineUpdateSemanticsNodeHandler update_semantics_node_handler;
   gpointer update_semantics_node_handler_data;
   GDestroyNotify update_semantics_node_handler_destroy_notify;
+
+  // Stored baton for plumbing vsync callbacks.
+  intptr_t vsync_baton;
 };
 
 G_DEFINE_QUARK(fl_engine_error_quark, fl_engine_error)
@@ -214,6 +218,48 @@ static bool fl_engine_gl_make_resource_current(void* user_data) {
   return result;
 }
 
+static gboolean fl_engine_request_vsync(gpointer user_data) {
+  FlEngine* self = static_cast<FlEngine*>(user_data);
+  GdkFrameClock* clk = gtk_widget_get_frame_clock(
+      GTK_WIDGET(fl_renderer_get_view(self->renderer)));
+  gdk_frame_clock_request_phase(clk, GDK_FRAME_CLOCK_PHASE_UPDATE);
+  return false;
+}
+
+static void fl_engine_vsync_callback(void* user_data, intptr_t btn) {
+  FlEngine* self = static_cast<FlEngine*>(user_data);
+  // Thread safety: only one of vsync_callback or handle_frame_clock_update can
+  // execute at one time. This is because VSync callback can only be requested
+  // upon the completion of the previous VSync callback.
+  self->vsync_baton = btn;
+  // Run frame clock operations on the main thread to synchronize the accesses.
+  g_idle_add(fl_engine_request_vsync, user_data);
+}
+
+static void fl_engine_handle_frame_clock_update(GdkFrameClock* clk,
+                                                void* user_data) {
+  FlEngine* self = static_cast<FlEngine*>(user_data);
+  if (self->vsync_baton != 0) {
+    // Note: it's crucial to reset the vsync_baton before we call OnVsync, since
+    // OnVsync (either synchronous or ran on another thread) might request
+    // another vsync callback inside it.
+    auto btn = self->vsync_baton;
+    self->vsync_baton = 0;
+    gint64 frame_time = gdk_frame_clock_get_frame_time(clk);
+    gint64 refresh_interval;
+    gint64 presentation_time;
+    gdk_frame_clock_get_refresh_info(clk, frame_time, &refresh_interval,
+                                     &presentation_time);
+    if (presentation_time == 0) {
+      // GDK could not predict next presentation due to lack of history.
+      // A fallback is used.
+      presentation_time = frame_time + refresh_interval;
+    }
+    self->embedder_api.OnVsync(self->engine, btn, frame_time * 1000,
+                               presentation_time * 1000);
+  }
+}
+
 // Called by the engine to determine if it is on the GTK thread.
 static bool fl_engine_runs_task_on_current_thread(void* user_data) {
   FlEngine* self = static_cast<FlEngine*>(user_data);
@@ -326,6 +372,7 @@ static void fl_engine_class_init(FlEngineClass* klass) {
 
 static void fl_engine_init(FlEngine* self) {
   self->thread = g_thread_self();
+  self->vsync_baton = 0;
 
   self->embedder_api.struct_size = sizeof(FlutterEngineProcTable);
   FlutterEngineGetProcAddresses(&self->embedder_api);
@@ -401,6 +448,11 @@ gboolean fl_engine_start(FlEngine* self, GError** error) {
       dart_entrypoint_args != nullptr ? g_strv_length(dart_entrypoint_args) : 0;
   args.dart_entrypoint_argv =
       reinterpret_cast<const char* const*>(dart_entrypoint_args);
+  args.vsync_callback = fl_engine_vsync_callback;
+  GdkFrameClock* clk = gtk_widget_get_frame_clock(
+      GTK_WIDGET(fl_renderer_get_view(self->renderer)));
+  g_signal_connect(clk, "update",
+                   G_CALLBACK(fl_engine_handle_frame_clock_update), self);
 
   FlutterCompositor compositor = {};
   compositor.struct_size = sizeof(FlutterCompositor);

shell/platform/linux/fl_view.cc

@@ -142,8 +142,8 @@ static void fl_view_geometry_changed(FlView* self) {
       self->engine, allocation.width * scale_factor,
       allocation.height * scale_factor, scale_factor);
 
-  fl_renderer_wait_for_frame(self->renderer, allocation.width * scale_factor,
-                             allocation.height * scale_factor);
+  // fl_renderer_wait_for_frame(self->renderer, allocation.width * scale_factor,
+  //                            allocation.height * scale_factor);
 }
 
 // Implements FlPluginRegistry::get_registrar_for_plugin.