Revert of 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")),
       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.
-  EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
-  if (!fence) {
-    callback.Run(gfx::SwapResult::SWAP_FAILED);
-    return;
+  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.
   }
 
-  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);
+  frame->ready = true;
+  SubmitFrame();
 }
 
 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