[android] set presentation time via eglPresentationTimeANDROID

Attempt to reland: #29727

TODO:

1. This isn't right in the cases where the frame has been resubmitted.
2. This hasn't been wired for impeller yet.

Author: iskakaushik

flow/surface_frame.h

@@ -11,6 +11,7 @@
 #include "flutter/common/graphics/gl_context_switch.h"
 #include "flutter/display_list/display_list_canvas_recorder.h"
 #include "flutter/fml/macros.h"
+#include "flutter/fml/time/time_point.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
@@ -72,6 +73,10 @@ class SurfaceFrame {
     //
     // Corresponds to EGL_KHR_partial_update
     std::optional<SkIRect> buffer_damage;
+
+    // Time at which this frame is scheduled to be presented. This is a hint
+    // that can be passed to the platform to drop queued frames.
+    fml::TimePoint presentation_time;
   };
 
   bool Submit();

shell/common/rasterizer.cc

@@ -604,6 +604,9 @@ RasterStatus Rasterizer::DrawToSurfaceUnsafe(
     }
 
     SurfaceFrame::SubmitInfo submit_info;
+    // TODO (kaushikiska): this can be in the past and might need to get snapped
+    // to future as this frame could have been resubmitted.
+    submit_info.presentation_time = frame_timings_recorder.GetVsyncTargetTime();
     if (damage) {
       submit_info.frame_damage = damage->GetFrameDamage();
       submit_info.buffer_damage = damage->GetBufferDamage();

shell/gpu/gpu_surface_gl_delegate.h

@@ -29,6 +29,10 @@ struct GLPresentInfo {
   // Damage is a hint to compositor telling it which parts of front buffer
   // need to be updated
   const std::optional<SkIRect>& damage;
+
+  // Time at which this frame is scheduled to be presented. This is a hint
+  // that can be passed to the platform to drop queued frames.
+  std::optional<fml::TimePoint> presentation_time = std::nullopt;
 };
 
 class GPUSurfaceGLDelegate {

shell/gpu/gpu_surface_gl_impeller.cc

@@ -63,6 +63,8 @@ std::unique_ptr<SurfaceFrame> GPUSurfaceGLImpeller::AcquireFrame(
       GLPresentInfo present_info = {
           .fbo_id = 0,
           .damage = std::nullopt,
+          // TODO (kaushikiska): wire-up presentation time to impeller backend.
+          .presentation_time = std::nullopt,
       };
       delegate->GLContextPresent(present_info);
     }

shell/platform/android/android_egl_surface.cc

@@ -60,6 +60,17 @@ void LogLastEGLError() {
   FML_LOG(ERROR) << "Unknown EGL Error";
 }
 
+namespace {
+
+static bool HasExtension(const char* extensions, const char* name) {
+  const char* r = strstr(extensions, name);
+  auto len = strlen(name);
+  // check that the extension name is terminated by space or null terminator
+  return r != nullptr && (r[len] == ' ' || r[len] == 0);
+}
+
+}  // namespace
+
 class AndroidEGLSurfaceDamage {
  public:
   void init(EGLDisplay display, EGLContext context) {
@@ -170,13 +181,6 @@ class AndroidEGLSurfaceDamage {
 
   bool partial_redraw_supported_;
 
-  bool HasExtension(const char* extensions, const char* name) {
-    const char* r = strstr(extensions, name);
-    auto len = strlen(name);
-    // check that the extension name is terminated by space or null terminator
-    return r != nullptr && (r[len] == ' ' || r[len] == 0);
-  }
-
   std::list<SkIRect> damage_history_;
 };
 
@@ -188,6 +192,14 @@ AndroidEGLSurface::AndroidEGLSurface(EGLSurface surface,
       context_(context),
       damage_(std::make_unique<AndroidEGLSurfaceDamage>()) {
   damage_->init(display_, context);
+
+  const char* extensions = eglQueryString(display, EGL_EXTENSIONS);
+
+  if (HasExtension(extensions, "EGL_ANDROID_presentation_time")) {
+    presentation_time_proc_ =
+        reinterpret_cast<PFNEGLPRESENTATIONTIMEANDROIDPROC>(
+            eglGetProcAddress("eglPresentationTimeANDROID"));
+  }
 }
 
 AndroidEGLSurface::~AndroidEGLSurface() {
@@ -240,6 +252,16 @@ void AndroidEGLSurface::SetDamageRegion(
   damage_->SetDamageRegion(display_, surface_, buffer_damage);
 }
 
+bool AndroidEGLSurface::SetPresentationTime(
+    const fml::TimePoint& presentation_time) {
+  if (presentation_time_proc_) {
+    const auto time_ns = presentation_time.ToEpochDelta().ToNanoseconds();
+    return presentation_time_proc_(display_, surface_, time_ns);
+  } else {
+    return false;
+  }
+}
+
 bool AndroidEGLSurface::SwapBuffers(
     const std::optional<SkIRect>& surface_damage) {
   TRACE_EVENT0("flutter", "AndroidContextGL::SwapBuffers");

shell/platform/android/android_egl_surface.h

@@ -5,9 +5,13 @@
 #ifndef FLUTTER_SHELL_PLATFORM_ANDROID_ANDROID_EGL_SURFACE_H_
 #define FLUTTER_SHELL_PLATFORM_ANDROID_ANDROID_EGL_SURFACE_H_
 
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <KHR/khrplatform.h>
 #include <optional>
 
 #include "flutter/fml/macros.h"
+#include "flutter/fml/time/time_point.h"
 #include "flutter/shell/platform/android/android_environment_gl.h"
 #include "third_party/skia/include/core/SkRect.h"
 
@@ -77,6 +81,12 @@ class AndroidEGLSurface {
   //              eglSetDamageRegionKHR
   void SetDamageRegion(const std::optional<SkIRect>& buffer_damage);
 
+  //----------------------------------------------------------------------------
+  /// @brief      Sets the presentation time for the current surface. This
+  //              corresponds to calling eglPresentationTimeAndroid when
+  //              available.
+  bool SetPresentationTime(const fml::TimePoint& presentation_time);
+
   //----------------------------------------------------------------------------
   /// @brief      This only applies to on-screen surfaces such as those created
   ///             by `AndroidContextGL::CreateOnscreenSurface`.
@@ -98,6 +108,7 @@ class AndroidEGLSurface {
   const EGLDisplay display_;
   const EGLContext context_;
   std::unique_ptr<AndroidEGLSurfaceDamage> damage_;
+  PFNEGLPRESENTATIONTIMEANDROIDPROC presentation_time_proc_;
 };
 
 }  // namespace flutter

shell/platform/android/android_surface_gl_skia.cc

@@ -156,6 +156,9 @@ void AndroidSurfaceGLSkia::GLContextSetDamageRegion(
 bool AndroidSurfaceGLSkia::GLContextPresent(const GLPresentInfo& present_info) {
   FML_DCHECK(IsValid());
   FML_DCHECK(onscreen_surface_);
+  if (present_info.presentation_time) {
+    onscreen_surface_->SetPresentationTime(*present_info.presentation_time);
+  }
   return onscreen_surface_->SwapBuffers(present_info.damage);
 }