Revert "Fix eglPresentationTimeANDROID is no effective"

flow/surface_frame.h

@@ -10,7 +10,6 @@
 
 #include "flutter/common/graphics/gl_context_switch.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"
 
@@ -67,12 +66,6 @@ class SurfaceFrame {
     //
     // Corresponds to EGL_KHR_partial_update
     std::optional<SkIRect> buffer_damage;
-
-    // The vsync target time.
-    //
-    // Backends may use this information to avoid overloading the GPU with
-    // multiple frames per vsync.
-    fml::TimePoint target_time;
   };
 
   bool Submit();

shell/common/rasterizer.cc

@@ -548,60 +548,60 @@ RasterStatus Rasterizer::DrawToSurfaceUnsafe(
           .supports_readback,  // surface supports pixel reads
       raster_thread_merger_    // thread merger
   );
-  if (!compositor_frame) {
-    return RasterStatus::kFailed;
-  }
+  if (compositor_frame) {
+    compositor_context_->raster_cache().PrepareNewFrame();
+    frame_timings_recorder.RecordRasterStart(fml::TimePoint::Now());
+
+    // Disable partial repaint if external_view_embedder_ SubmitFrame is
+    // involved - ExternalViewEmbedder unconditionally clears the entire
+    // surface and also partial repaint with platform view present is something
+    // that still need to be figured out.
+    bool disable_partial_repaint =
+        external_view_embedder_ &&
+        (!raster_thread_merger_ || raster_thread_merger_->IsMerged());
+
+    FrameDamage damage;
+    if (!disable_partial_repaint && frame->framebuffer_info().existing_damage) {
+      damage.SetPreviousLayerTree(last_layer_tree_.get());
+      damage.AddAdditonalDamage(*frame->framebuffer_info().existing_damage);
+    }
 
-  compositor_context_->raster_cache().PrepareNewFrame();
-  frame_timings_recorder.RecordRasterStart(fml::TimePoint::Now());
+    RasterStatus raster_status =
+        compositor_frame->Raster(layer_tree, false, &damage);
+    if (raster_status == RasterStatus::kFailed ||
+        raster_status == RasterStatus::kSkipAndRetry) {
+      return raster_status;
+    }
 
-  // Disable partial repaint if external_view_embedder_ SubmitFrame is
-  // involved - ExternalViewEmbedder unconditionally clears the entire
-  // surface and also partial repaint with platform view present is something
-  // that still need to be figured out.
-  bool disable_partial_repaint =
-      external_view_embedder_ &&
-      (!raster_thread_merger_ || raster_thread_merger_->IsMerged());
+    SurfaceFrame::SubmitInfo submit_info;
+    submit_info.frame_damage = damage.GetFrameDamage();
+    submit_info.buffer_damage = damage.GetBufferDamage();
 
-  FrameDamage damage;
-  if (!disable_partial_repaint && frame->framebuffer_info().existing_damage) {
-    damage.SetPreviousLayerTree(last_layer_tree_.get());
-    damage.AddAdditonalDamage(*frame->framebuffer_info().existing_damage);
-  }
-
-  RasterStatus raster_status =
-      compositor_frame->Raster(layer_tree, false, &damage);
-  if (raster_status == RasterStatus::kFailed ||
-      raster_status == RasterStatus::kSkipAndRetry) {
-    return raster_status;
-  }
+    frame->set_submit_info(submit_info);
 
-  SurfaceFrame::SubmitInfo submit_info;
-  submit_info.frame_damage = damage.GetFrameDamage();
-  submit_info.buffer_damage = damage.GetBufferDamage();
-  submit_info.target_time = frame_timings_recorder.GetVsyncTargetTime();
-
-  frame->set_submit_info(submit_info);
+    if (external_view_embedder_ &&
+        (!raster_thread_merger_ || raster_thread_merger_->IsMerged())) {
+      FML_DCHECK(!frame->IsSubmitted());
+      external_view_embedder_->SubmitFrame(surface_->GetContext(),
+                                           std::move(frame));
+    } else {
+      frame->Submit();
+    }
 
-  if (external_view_embedder_ &&
-      (!raster_thread_merger_ || raster_thread_merger_->IsMerged())) {
-    FML_DCHECK(!frame->IsSubmitted());
-    external_view_embedder_->SubmitFrame(surface_->GetContext(),
-                                         std::move(frame));
-  } else {
-    frame->Submit();
-  }
+    compositor_context_->raster_cache().CleanupAfterFrame();
+    frame_timings_recorder.RecordRasterEnd(
+        &compositor_context_->raster_cache());
+    FireNextFrameCallbackIfPresent();
 
-  compositor_context_->raster_cache().CleanupAfterFrame();
-  frame_timings_recorder.RecordRasterEnd(&compositor_context_->raster_cache());
-  FireNextFrameCallbackIfPresent();
+    if (surface_->GetContext()) {
+      TRACE_EVENT0("flutter", "PerformDeferredSkiaCleanup");
+      surface_->GetContext()->performDeferredCleanup(kSkiaCleanupExpiration);
+    }
 
-  if (surface_->GetContext()) {
-    TRACE_EVENT0("flutter", "PerformDeferredSkiaCleanup");
-    surface_->GetContext()->performDeferredCleanup(kSkiaCleanupExpiration);
+    return raster_status;
   }
 
-  return raster_status;
+  return RasterStatus::kFailed;
 }
 
 static sk_sp<SkData> ScreenshotLayerTreeAsPicture(

shell/common/shell_test_platform_view_gl.cc

@@ -63,8 +63,7 @@ bool ShellTestPlatformViewGL::GLContextClearCurrent() {
 }
 
 // |GPUSurfaceGLDelegate|
-bool ShellTestPlatformViewGL::GLContextPresent(fml::TimePoint target_time,
-                                               uint32_t fbo_id) {
+bool ShellTestPlatformViewGL::GLContextPresent(uint32_t fbo_id) {
   return gl_surface_.Present();
 }
 

shell/common/shell_test_platform_view_gl.h

@@ -58,7 +58,7 @@ class ShellTestPlatformViewGL : public ShellTestPlatformView,
   bool GLContextClearCurrent() override;
 
   // |GPUSurfaceGLDelegate|
-  bool GLContextPresent(fml::TimePoint target_time, uint32_t fbo_id) override;
+  bool GLContextPresent(uint32_t fbo_id) override;
 
   // |GPUSurfaceGLDelegate|
   intptr_t GLContextFBO(GLFrameInfo frame_info) const override;

shell/gpu/gpu_surface_gl.cc

@@ -242,9 +242,7 @@ std::unique_ptr<SurfaceFrame> GPUSurfaceGL::AcquireFrame(const SkISize& size) {
   SurfaceFrame::SubmitCallback submit_callback =
       [weak = weak_factory_.GetWeakPtr()](const SurfaceFrame& surface_frame,
                                           SkCanvas* canvas) {
-        return weak ? weak->PresentSurface(
-                          surface_frame.submit_info().target_time, canvas)
-                    : false;
+        return weak ? weak->PresentSurface(canvas) : false;
       };
 
   framebuffer_info = delegate_->GLContextFramebufferInfo();
@@ -253,8 +251,7 @@ std::unique_ptr<SurfaceFrame> GPUSurfaceGL::AcquireFrame(const SkISize& size) {
                                         std::move(context_switch));
 }
 
-bool GPUSurfaceGL::PresentSurface(fml::TimePoint target_time,
-                                  SkCanvas* canvas) {
+bool GPUSurfaceGL::PresentSurface(SkCanvas* canvas) {
   if (delegate_ == nullptr || canvas == nullptr || context_ == nullptr) {
     return false;
   }
@@ -264,7 +261,7 @@ bool GPUSurfaceGL::PresentSurface(fml::TimePoint target_time,
     onscreen_surface_->getCanvas()->flush();
   }
 
-  if (!delegate_->GLContextPresent(target_time, fbo_id_)) {
+  if (!delegate_->GLContextPresent(fbo_id_)) {
     return false;
   }
 

shell/gpu/gpu_surface_gl.h

@@ -60,7 +60,7 @@ class GPUSurfaceGL : public Surface {
       const SkISize& untransformed_size,
       const SkMatrix& root_surface_transformation);
 
-  bool PresentSurface(fml::TimePoint target_time, SkCanvas* canvas);
+  bool PresentSurface(SkCanvas* canvas);
 
   GPUSurfaceGLDelegate* delegate_;
   sk_sp<GrDirectContext> context_;
@@ -77,7 +77,6 @@ class GPUSurfaceGL : public Surface {
 
   // WeakPtrFactory must be the last member.
   fml::TaskRunnerAffineWeakPtrFactory<GPUSurfaceGL> weak_factory_;
-
   FML_DISALLOW_COPY_AND_ASSIGN(GPUSurfaceGL);
 };
 

shell/gpu/gpu_surface_gl_delegate.h

@@ -33,8 +33,7 @@ class GPUSurfaceGLDelegate {
 
   // Called to present the main GL surface. This is only called for the main GL
   // context and not any of the contexts dedicated for IO.
-  virtual bool GLContextPresent(fml::TimePoint target_time,
-                                uint32_t fbo_id) = 0;
+  virtual bool GLContextPresent(uint32_t fbo_id) = 0;
 
   // The ID of the main window bound framebuffer. Typically FBO0.
   virtual intptr_t GLContextFBO(GLFrameInfo frame_info) const = 0;

shell/platform/android/BUILD.gn

@@ -46,7 +46,6 @@ executable("flutter_shell_native_unittests") {
   public_configs = [ "//flutter:config" ]
   deps = [
     ":flutter_shell_native_src",
-    "//flutter/fml",
     "//third_party/googletest:gmock",
     "//third_party/googletest:gtest",
   ]

shell/platform/android/android_context_gl.cc

@@ -8,7 +8,6 @@
 
 #include <utility>
 
-#include "android_environment_gl.h"
 #include "flutter/fml/trace_event.h"
 
 namespace flutter {
@@ -106,14 +105,13 @@ static bool TeardownContext(EGLDisplay display, EGLContext context) {
   return true;
 }
 
-AndroidEGLSurface::AndroidEGLSurface(
-    EGLSurface surface,
-    fml::RefPtr<AndroidEnvironmentGL> environment,
-    EGLContext context)
-    : surface_(surface), environment_(environment), context_(context) {}
+AndroidEGLSurface::AndroidEGLSurface(EGLSurface surface,
+                                     EGLDisplay display,
+                                     EGLContext context)
+    : surface_(surface), display_(display), context_(context) {}
 
 AndroidEGLSurface::~AndroidEGLSurface() {
-  auto result = eglDestroySurface(environment_->Display(), surface_);
+  auto result = eglDestroySurface(display_, surface_);
   FML_DCHECK(result == EGL_TRUE);
 }
 
@@ -122,28 +120,25 @@ bool AndroidEGLSurface::IsValid() const {
 }
 
 bool AndroidEGLSurface::MakeCurrent() const {
-  if (eglMakeCurrent(environment_->Display(), surface_, surface_, context_) !=
-      EGL_TRUE) {
+  if (eglMakeCurrent(display_, surface_, surface_, context_) != EGL_TRUE) {
     FML_LOG(ERROR) << "Could not make the context current";
     LogLastEGLError();
     return false;
   }
   return true;
 }
 
-bool AndroidEGLSurface::SwapBuffers(fml::TimePoint target_time) {
+bool AndroidEGLSurface::SwapBuffers() {
   TRACE_EVENT0("flutter", "AndroidContextGL::SwapBuffers");
-  environment_->SetPresentationTime(surface_, target_time);
-  return eglSwapBuffers(environment_->Display(), surface_);
+  return eglSwapBuffers(display_, surface_);
 }
 
 SkISize AndroidEGLSurface::GetSize() const {
   EGLint width = 0;
   EGLint height = 0;
 
-  if (!eglQuerySurface(environment_->Display(), surface_, EGL_WIDTH, &width) ||
-      !eglQuerySurface(environment_->Display(), surface_, EGL_HEIGHT,
-                       &height)) {
+  if (!eglQuerySurface(display_, surface_, EGL_WIDTH, &width) ||
+      !eglQuerySurface(display_, surface_, EGL_HEIGHT, &height)) {
     FML_LOG(ERROR) << "Unable to query EGL surface size";
     LogLastEGLError();
     return SkISize::Make(0, 0);
@@ -234,24 +229,27 @@ std::unique_ptr<AndroidEGLSurface> AndroidContextGL::CreateOnscreenSurface(
   if (window->IsFakeWindow()) {
     return CreatePbufferSurface();
   } else {
+    EGLDisplay display = environment_->Display();
+
     const EGLint attribs[] = {EGL_NONE};
 
     EGLSurface surface = eglCreateWindowSurface(
-        environment_->Display(), config_,
+        display, config_,
         reinterpret_cast<EGLNativeWindowType>(window->handle()), attribs);
-    return std::make_unique<AndroidEGLSurface>(surface, environment_, context_);
+    return std::make_unique<AndroidEGLSurface>(surface, display, context_);
   }
 }
 
 std::unique_ptr<AndroidEGLSurface> AndroidContextGL::CreateOffscreenSurface()
     const {
   // We only ever create pbuffer surfaces for background resource loading
   // contexts. We never bind the pbuffer to anything.
+  EGLDisplay display = environment_->Display();
+
   const EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
 
-  EGLSurface surface =
-      eglCreatePbufferSurface(environment_->Display(), config_, attribs);
-  return std::make_unique<AndroidEGLSurface>(surface, environment_,
+  EGLSurface surface = eglCreatePbufferSurface(display, config_, attribs);
+  return std::make_unique<AndroidEGLSurface>(surface, display,
                                              resource_context_);
 }
 
@@ -262,7 +260,7 @@ std::unique_ptr<AndroidEGLSurface> AndroidContextGL::CreatePbufferSurface()
   const EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
 
   EGLSurface surface = eglCreatePbufferSurface(display, config_, attribs);
-  return std::make_unique<AndroidEGLSurface>(surface, environment_, context_);
+  return std::make_unique<AndroidEGLSurface>(surface, display, context_);
 }
 
 fml::RefPtr<AndroidEnvironmentGL> AndroidContextGL::Environment() const {

shell/platform/android/android_context_gl.h

@@ -5,10 +5,6 @@
 #ifndef FLUTTER_SHELL_PLATFORM_ANDROID_ANDROID_CONTEXT_GL_H_
 #define FLUTTER_SHELL_PLATFORM_ANDROID_ANDROID_CONTEXT_GL_H_
 
-#include <EGL/egl.h>
-#define EGL_EGLEXT_PROTOTYPES
-#include <EGL/eglext.h>
-
 #include "flutter/fml/macros.h"
 #include "flutter/fml/memory/ref_counted.h"
 #include "flutter/fml/memory/ref_ptr.h"
@@ -29,9 +25,7 @@ namespace flutter {
 ///
 class AndroidEGLSurface {
  public:
-  AndroidEGLSurface(EGLSurface surface,
-                    fml::RefPtr<AndroidEnvironmentGL> environment,
-                    EGLContext context);
+  AndroidEGLSurface(EGLSurface surface, EGLDisplay display, EGLContext context);
   ~AndroidEGLSurface();
 
   //----------------------------------------------------------------------------
@@ -53,11 +47,9 @@ class AndroidEGLSurface {
   /// @brief      This only applies to on-screen surfaces such as those created
   ///             by `AndroidContextGL::CreateOnscreenSurface`.
   ///
-  /// @param target_time  The vsync target time for the buffer.
-  ///
   /// @return     Whether the EGL surface color buffer was swapped.
   ///
-  bool SwapBuffers(fml::TimePoint target_time);
+  bool SwapBuffers();
 
   //----------------------------------------------------------------------------
   /// @return     The size of an `EGLSurface`.
@@ -66,7 +58,7 @@ class AndroidEGLSurface {
 
  private:
   const EGLSurface surface_;
-  const fml::RefPtr<AndroidEnvironmentGL> environment_;
+  const EGLDisplay display_;
   const EGLContext context_;
 };