ozone: Wait on EGLFence before committing buffers. Avoid using GL.

ui/ozone/platform/drm/gpu/gbm_surfaceless.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/ozone/platform/drm/gpu/gbm_surfaceless.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
 
 GbmSurfaceless::GbmSurfaceless(GbmSurfaceFactory* surface_factory,
                                std::unique_ptr<DrmWindowProxy> window,
                                gfx::AcceleratedWidget widget)
     : SurfacelessEGL(gfx::Size()),
       surface_factory_(surface_factory),
       window_(std::move(window)),
       widget_(widget),
       has_implicit_external_sync_(
           HasEGLExtension("EGL_ARM_implicit_external_sync")),
-      has_image_flush_external_(
-          HasEGLExtension("EGL_EXT_image_flush_external")),

[marcheu, 2017/05/02 21:10:14]

hmm, note that we need this to happen somehow... But right now it is also on the
wrong context which I guess has no effect. Should the eglimageflush be moved
outside of ozone?

[Daniele Castagna, 2017/05/02 21:23:31]

This happens per image. Look at GLImageNativePixmap::Flush, it gets called from
unsubmitted_frames_.back()->Flush(); in GbmSurfaceless::SwapBuffersAsync just
before we insert and wait for the fence.
The boolean here was just to make sure we'd insert the fence if
eglImageFlushExternalEXT was used. Now we always insert the fence so we don't
need the check at this level.

eglImageFlushExternalEXT shouldn't use the GL context, so it should work.

       weak_factory_(this) {
   surface_factory_->RegisterSurface(window_->widget(), this);
   unsubmitted_frames_.push_back(base::MakeUnique<PendingFrame>());
 }
 
 void GbmSurfaceless::QueueOverlayPlane(const OverlayPlane& plane) {
   planes_.push_back(plane);
 }
 
 bool GbmSurfaceless::Initialize(gl::GLSurfaceFormat format) {
@@ skipping 46 matching lines @@
 }
 
 void GbmSurfaceless::SwapBuffersAsync(const SwapCompletionCallback& callback) {
   TRACE_EVENT0("drm", "GbmSurfaceless::SwapBuffersAsync");
   // If last swap failed, don't try to schedule new ones.
   if (!last_swap_buffers_result_) {
     callback.Run(gfx::SwapResult::SWAP_FAILED);
     return;
   }
 
-  glFlush();
   unsubmitted_frames_.back()->Flush();
 
   SwapCompletionCallback surface_swap_callback = base::Bind(
       &GbmSurfaceless::SwapCompleted, weak_factory_.GetWeakPtr(), callback);
 
   PendingFrame* frame = unsubmitted_frames_.back().get();
   frame->callback = surface_swap_callback;
   unsubmitted_frames_.push_back(base::MakeUnique<PendingFrame>());
 
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
-  if (has_implicit_external_sync_ || has_image_flush_external_) {
-    EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
-    if (!fence) {
-      callback.Run(gfx::SwapResult::SWAP_FAILED);
-      return;
-    }
-
-    base::Closure fence_wait_task =
-        base::Bind(&WaitForFence, GetDisplay(), fence);
-
-    base::Closure fence_retired_callback =
-        base::Bind(&GbmSurfaceless::FenceRetired, weak_factory_.GetWeakPtr(),
-                   fence, frame);
-
-    base::PostTaskWithTraitsAndReply(
-        FROM_HERE, base::TaskTraits()
-                       .WithShutdownBehavior(
-                           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
-                       .MayBlock(),
-        fence_wait_task, fence_retired_callback);
-    return;  // Defer frame submission until fence signals.
+  EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
+  if (!fence) {
+    callback.Run(gfx::SwapResult::SWAP_FAILED);
+    return;
   }
 
-  frame->ready = true;
-  SubmitFrame();
+  base::Closure fence_wait_task =
+      base::Bind(&WaitForFence, GetDisplay(), fence);
+
+  base::Closure fence_retired_callback = base::Bind(
+      &GbmSurfaceless::FenceRetired, weak_factory_.GetWeakPtr(), fence, frame);
+
+  base::PostTaskWithTraitsAndReply(
+      FROM_HERE,
+      base::TaskTraits()
+          .WithShutdownBehavior(
+              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
+          .MayBlock(),
+      fence_wait_task, fence_retired_callback);
 }
 
 void GbmSurfaceless::PostSubBufferAsync(
     int x,
     int y,
     int width,
     int height,
     const SwapCompletionCallback& callback) {
   // The actual sub buffer handling is handled at higher layers.
   SwapBuffersAsync(callback);
@@ skipping 51 matching lines @@
     unsubmitted_frames_.erase(unsubmitted_frames_.begin());
     swap_buffers_pending_ = true;
 
     if (!frame->ScheduleOverlayPlanes(widget_)) {
       // |callback| is a wrapper for SwapCompleted(). Call it to properly
       // propagate the failed state.
       frame->callback.Run(gfx::SwapResult::SWAP_FAILED);
       return;
     }
 
-    if (IsUniversalDisplayLinkDevice())
-      glFinish();
-
     window_->SchedulePageFlip(planes_, frame->callback);
     planes_.clear();
   }
 }
 
 EGLSyncKHR GbmSurfaceless::InsertFence(bool implicit) {
   const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
                                 EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
                                 EGL_NONE};
   return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR,
@@ skipping 11 matching lines @@
   callback.Run(result);
   swap_buffers_pending_ = false;
   if (result == gfx::SwapResult::SWAP_FAILED) {
     last_swap_buffers_result_ = false;
     return;
   }
 
   SubmitFrame();
 }
 
-bool GbmSurfaceless::IsUniversalDisplayLinkDevice() {
-  return planes_.empty() ? false : planes_[0].buffer->RequiresGlFinish();
-}
-
 }  // namespace ui