[ozone/wayland]GbmSurfacelessWayland wait for in-fences provided by

SkiaRenderer

SkiaOutputDeviceBufferQueue inserts a GpuFence when scheduling primary
plane as an overlay. This fence is inserted after the gl commands for
compositing. GbmSurfacelessWayland should use this fence when available.
Inserting another fence is necessary.

Change-Id: I5ec29019bd8917bdd3ea6e3f10e2d8f1327144f9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2252467Reviewed-by: Maksim Sisov <msisov@igalia.com>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Commit-Queue: Kramer Ge <fangzhoug@chromium.org>
Commit-Queue: Robert Kroeger <rjkroege@chromium.org>
Auto-Submit: Kramer Ge <fangzhoug@chromium.org>
Cr-Commit-Position: refs/heads/master@{#780295}

ui/ozone/platform/wayland/gpu/gbm_surfaceless_wayland.cc

@@ -18,12 +18,17 @@ namespace ui {
 
 namespace {
 
-void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
+void WaitForEGLFence(EGLDisplay display, EGLSyncKHR fence) {
   eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                        EGL_FOREVER_KHR);
   eglDestroySyncKHR(display, fence);
 }
 
+void WaitForGpuFences(std::vector<std::unique_ptr<gfx::GpuFence>> fences) {
+  for (auto& fence : fences)
+    fence->Wait();
+}
+
 }  // namespace
 
 GbmSurfacelessWayland::GbmSurfacelessWayland(
@@ -41,7 +46,7 @@ GbmSurfacelessWayland::GbmSurfacelessWayland(
 
 void GbmSurfacelessWayland::QueueOverlayPlane(OverlayPlane plane,
                                               uint32_t buffer_id) {
-  planes_.push_back({std::move(plane), buffer_id});
+  unsubmitted_frames_.back()->planes.push_back({std::move(plane), buffer_id});
 }
 
 bool GbmSurfacelessWayland::ScheduleOverlayPlane(
@@ -103,21 +108,35 @@ void GbmSurfacelessWayland::SwapBuffersAsync(
   PendingFrame* frame = unsubmitted_frames_.back().get();
   frame->completion_callback = std::move(completion_callback);
   frame->presentation_callback = std::move(presentation_callback);
+  frame->ScheduleOverlayPlanes(widget_);
+
   unsubmitted_frames_.push_back(std::make_unique<PendingFrame>());
 
-  if (!use_egl_fence_sync_) {
+  if (!use_egl_fence_sync_ || !frame->schedule_planes_succeeded) {
     frame->ready = true;
     SubmitFrame();
     return;
   }
 
-  // TODO: the following should be replaced by a per surface flush as it gets
-  // implemented in GL drivers.
-  EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
-  CHECK_NE(fence, EGL_NO_SYNC_KHR) << "eglCreateSyncKHR failed";
+  std::vector<std::unique_ptr<gfx::GpuFence>> fences;
+  // Uset in-fences provided in the overlays. If there are none, we insert our
+  // own fence and wait.
+  for (auto& plane : frame->planes) {
+    if (plane.plane.gpu_fence)
+      fences.push_back(std::move(plane.plane.gpu_fence));
+  }
+
+  base::OnceClosure fence_wait_task;
+  if (!fences.empty()) {
+    fence_wait_task = base::BindOnce(&WaitForGpuFences, std::move(fences));
+  } else {
+    // TODO: the following should be replaced by a per surface flush as it gets
+    // implemented in GL drivers.
+    EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
+    CHECK_NE(fence, EGL_NO_SYNC_KHR) << "eglCreateSyncKHR failed";
 
-  base::OnceClosure fence_wait_task =
-      base::BindOnce(&WaitForFence, GetDisplay(), fence);
+    fence_wait_task = base::BindOnce(&WaitForEGLFence, GetDisplay(), fence);
+  }
 
   base::OnceClosure fence_retired_callback = base::BindOnce(
       &GbmSurfacelessWayland::FenceRetired, weak_factory_.GetWeakPtr(), frame);
@@ -182,12 +201,14 @@ GbmSurfacelessWayland::PendingFrame::PendingFrame() {}
 
 GbmSurfacelessWayland::PendingFrame::~PendingFrame() {}
 
-bool GbmSurfacelessWayland::PendingFrame::ScheduleOverlayPlanes(
+void GbmSurfacelessWayland::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
-  for (auto& overlay : overlays)
+  for (auto& overlay : overlays) {
     if (!overlay.ScheduleOverlayPlane(widget))
-      return false;
-  return true;
+      return;
+  }
+  schedule_planes_succeeded = true;
+  return;
 }
 
 void GbmSurfacelessWayland::PendingFrame::Flush() {
@@ -202,10 +223,7 @@ void GbmSurfacelessWayland::SubmitFrame() {
     submitted_frame_ = std::move(unsubmitted_frames_.front());
     unsubmitted_frames_.erase(unsubmitted_frames_.begin());
 
-    bool schedule_planes_succeeded =
-        submitted_frame_->ScheduleOverlayPlanes(widget_);
-
-    if (!schedule_planes_succeeded) {
+    if (!submitted_frame_->schedule_planes_succeeded) {
       last_swap_buffers_result_ = false;
 
       std::move(submitted_frame_->completion_callback)
@@ -218,11 +236,13 @@ void GbmSurfacelessWayland::SubmitFrame() {
       return;
     }
 
-    submitted_frame_->buffer_id = planes_.back().buffer_id;
-    buffer_manager_->CommitBuffer(widget_, submitted_frame_->buffer_id,
+    DCHECK_EQ(submitted_frame_->planes.size(), 1u);
+    submitted_frame_->buffer_id = submitted_frame_->planes.back().buffer_id;
+    buffer_manager_->CommitBuffer(widget_,
+                                  submitted_frame_->planes.back().buffer_id,
                                   submitted_frame_->damage_region_);
 
-    planes_.clear();
+    submitted_frame_->planes.clear();
   }
 }
 

ui/ozone/platform/wayland/gpu/gbm_surfaceless_wayland.h

@@ -71,11 +71,19 @@ class GbmSurfacelessWayland : public gl::SurfacelessEGL,
   void OnPresentation(uint32_t buffer_id,
                       const gfx::PresentationFeedback& feedback) override;
 
+  struct PlaneData {
+    OverlayPlane plane;
+    // The id of the buffer, which represents buffer that backs this overlay
+    // plane.
+    const uint32_t buffer_id;
+  };
+
   struct PendingFrame {
     PendingFrame();
     ~PendingFrame();
 
-    bool ScheduleOverlayPlanes(gfx::AcceleratedWidget widget);
+    // Queues overlay configs to |planes|.
+    void ScheduleOverlayPlanes(gfx::AcceleratedWidget widget);
     void Flush();
 
     bool ready = false;
@@ -90,11 +98,9 @@ class GbmSurfacelessWayland : public gl::SurfacelessEGL,
     std::vector<gl::GLSurfaceOverlay> overlays;
     SwapCompletionCallback completion_callback;
     PresentationCallback presentation_callback;
-  };
 
-  struct PlaneData {
-    OverlayPlane plane;
-    const uint32_t buffer_id;
+    bool schedule_planes_succeeded = false;
+    std::vector<PlaneData> planes;
   };
 
   void SubmitFrame();
@@ -106,7 +112,6 @@ class GbmSurfacelessWayland : public gl::SurfacelessEGL,
   void SetNoGLFlushForTests();
 
   WaylandBufferManagerGpu* const buffer_manager_;
-  std::vector<PlaneData> planes_;
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   gfx::AcceleratedWidget widget_;