ozone: Add support for using overlay plane fences in ozone_demo

This commit prepares ozone_demo to use GpuFences for overlay planes,
when support for them lands in any of the Ozone backends. The
--use-gpu-fences ozone_demo flag controls whether to enable the use of
fences or use the existing glFinish mechanism.

Bug: 828393
Test: Run ozone_demo on Ozone-DRM
Change-Id: I797e9445479ff4a9768cb89033d1dd6fd826b5ae
Reviewed-on: https://chromium-review.googlesource.com/1021693
Commit-Queue: Daniele Castagna <dcastagna@chromium.org>
Reviewed-by: Michael Spang <spang@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Cr-Commit-Position: refs/heads/master@{#559412}

ui/ozone/demo/ozone_demo.cc

@@ -39,15 +39,16 @@ int main(int argc, char** argv) {
   logging::InitLogging(settings);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kHelp)) {
-    std::cout <<
-        "Usage:\n\n"
-        "  --disable-gpu               Force software rendering\n"
-        "  --disable-surfaceless       Don't use surfaceless EGL\n"
-        "  --window-size=WIDTHxHEIGHT  Specify window size\n"
-        "  --partial-primary-plane     "
-        "Use smaller than fullscreen primary plane\n"
-        "  --enable-overlay            Use an overlay plane\n"
-        "  --disable-primary-plane     Don't use the primary plane\n";
+    std::cout << "Usage:\n\n"
+                 "  --disable-gpu               Force software rendering\n"
+                 "  --disable-surfaceless       Don't use surfaceless EGL\n"
+                 "  --window-size=WIDTHxHEIGHT  Specify window size\n"
+                 "  --partial-primary-plane     "
+                 "Use smaller than fullscreen primary plane\n"
+                 "  --enable-overlay            Use an overlay plane\n"
+                 "  --disable-primary-plane     Don't use the primary plane\n"
+                 "  --use-gpu-fences            "
+                 "Use GpuFences for buffer display synchronization\n";
 
     // TODO(hoegsberg): We should add a little more help text about how these
     // options interact and depend on each other.

ui/ozone/demo/surfaceless_gl_renderer.cc

@@ -16,6 +16,7 @@
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_image_native_pixmap.h"
 #include "ui/gl/gl_surface.h"
@@ -173,11 +174,22 @@ bool SurfacelessGlRenderer::Initialize() {
       glViewport(0, 0, overlay_size.width(), overlay_size.height());
       glClearColor(i, 1.0, 0.0, 1.0);
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+      // Ensure that the rendering has been committed to the buffer and thus
+      // that the buffer is ready for display without additional
+      // synchronization. This allows us to avoid using fences for display
+      // synchronization of the non-overlay buffers in RenderFrame.
+      glFinish();
     }
   }
 
   disable_primary_plane_ = command_line->HasSwitch("disable-primary-plane");
 
+  use_gpu_fences_ = command_line->HasSwitch("use-gpu-fences");
+  // The GLSurface needs to be prepared to accept plane fences,
+  // otherwise any fences sent to it will be ignored.
+  if (use_gpu_fences_)
+    surface_->SetUsePlaneGpuFences();
+
   // Schedule the initial render.
   PostRenderFrameTask(gfx::SwapResult::SWAP_ACK);
   return true;
@@ -229,10 +241,20 @@ void SurfacelessGlRenderer::RenderFrame() {
 
   if (!disable_primary_plane_) {
     CHECK(overlay_list.front().overlay_handled);
+
+    // Optionally use a fence to synchronize overlay plane display, if
+    // requested when invoking ozone_demo. Note that currently only the primary
+    // plane needs to use a fence, since its buffers are dynamically updated
+    // every frame. The buffers for non-primary planes are only drawn to during
+    // initialization and guaranteed to be ready for display (see Initialize),
+    // so no additional fence synchronization is needed for them.
+    std::unique_ptr<gl::GLFence> gl_fence =
+        use_gpu_fences_ ? gl::GLFence::CreateForGpuFence() : nullptr;
+
     surface_->ScheduleOverlayPlane(
         0, gfx::OVERLAY_TRANSFORM_NONE, buffers_[back_buffer_]->image(),
         primary_plane_rect_, gfx::RectF(0, 0, 1, 1), false,
-        /* gpu_fence */ nullptr);
+        gl_fence ? gl_fence->GetGpuFence() : nullptr);
   }
 
   if (overlay_buffers_[0] && overlay_list.back().overlay_handled) {

ui/ozone/demo/surfaceless_gl_renderer.h

@@ -59,6 +59,7 @@ class SurfacelessGlRenderer : public RendererBase {
   std::unique_ptr<BufferWrapper> overlay_buffers_[2];
   bool disable_primary_plane_ = false;
   gfx::Rect primary_plane_rect_;
+  bool use_gpu_fences_ = false;
 
   std::unique_ptr<OverlayCandidatesOzone> overlay_checker_;