Add support for EXT_image_flush_external extension

ui/gl/init/gl_surface_ozone.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/gl/init/gl_surface_ozone.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 198 matching lines @@
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override;
   EGLConfig GetConfig() override;
 
  protected:
   struct PendingFrame {
     PendingFrame();
 
     bool ScheduleOverlayPlanes(gfx::AcceleratedWidget widget);
+    void Flush();
 
     bool ready;
     std::vector<GLSurfaceOverlay> overlays;
     SwapCompletionCallback callback;
   };
 
   ~GLSurfaceOzoneSurfaceless() override;
 
   void SubmitFrame();
 
-  EGLSyncKHR InsertFence();
+  EGLSyncKHR InsertFence(bool implicit);
   void FenceRetired(EGLSyncKHR fence, PendingFrame* frame);
 
   void SwapCompleted(const SwapCompletionCallback& callback,
                      gfx::SwapResult result);
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   gfx::AcceleratedWidget widget_;
   std::unique_ptr<gfx::VSyncProvider> vsync_provider_;
   ScopedVector<PendingFrame> unsubmitted_frames_;
   bool has_implicit_external_sync_;
+  bool has_image_flush_external_;
   bool last_swap_buffers_result_;
   bool swap_buffers_pending_;
 
   base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
 
 GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {}
 
 bool GLSurfaceOzoneSurfaceless::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
   for (const auto& overlay : overlays)
     if (!overlay.ScheduleOverlayPlane(widget))
       return false;
   return true;
 }
 
+void GLSurfaceOzoneSurfaceless::PendingFrame::Flush() {
+  for (const auto& overlay : overlays)
+    overlay.Flush();
+}
+
 GLSurfaceOzoneSurfaceless::GLSurfaceOzoneSurfaceless(
     std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     gfx::AcceleratedWidget widget)
     : SurfacelessEGL(gfx::Size()),
       ozone_surface_(std::move(ozone_surface)),
       widget_(widget),
       has_implicit_external_sync_(
           HasEGLExtension("EGL_ARM_implicit_external_sync")),
+      has_image_flush_external_(
+          HasEGLExtension("EGL_EXT_image_flush_external")),
       last_swap_buffers_result_(true),
       swap_buffers_pending_(false),
       weak_factory_(this) {
   unsubmitted_frames_.push_back(new PendingFrame());
 }
 
 bool GLSurfaceOzoneSurfaceless::Initialize(GLSurface::Format format) {
   if (!SurfacelessEGL::Initialize(format))
     return false;
   vsync_provider_ = ozone_surface_->CreateVSyncProvider();
   if (!vsync_provider_)
     return false;
   return true;
 }
 
 bool GLSurfaceOzoneSurfaceless::Resize(const gfx::Size& size,
                                        float scale_factor,
                                        bool has_alpha) {
   if (!ozone_surface_->ResizeNativeWindow(size))
     return false;
 
   return SurfacelessEGL::Resize(size, scale_factor, has_alpha);
 }
 
 gfx::SwapResult GLSurfaceOzoneSurfaceless::SwapBuffers() {
   glFlush();
+
+  unsubmitted_frames_.back()->Flush();
+
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
-  if (has_implicit_external_sync_) {
-    EGLSyncKHR fence = InsertFence();
+  if (has_implicit_external_sync_ || has_image_flush_external_) {
+    EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
     if (!fence)
       return gfx::SwapResult::SWAP_FAILED;
 
     EGLDisplay display = GetDisplay();
     WaitForFence(display, fence);
     eglDestroySyncKHR(display, fence);
   }
 
   unsubmitted_frames_.back()->ScheduleOverlayPlanes(widget_);
   unsubmitted_frames_.back()->overlays.clear();
@@ skipping 43 matching lines @@
 
 void GLSurfaceOzoneSurfaceless::SwapBuffersAsync(
     const SwapCompletionCallback& callback) {
   // 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(&GLSurfaceOzoneSurfaceless::SwapCompleted,
                  weak_factory_.GetWeakPtr(), callback);
 
   PendingFrame* frame = unsubmitted_frames_.back();
   frame->callback = surface_swap_callback;
   unsubmitted_frames_.push_back(new PendingFrame());
 
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
-  if (has_implicit_external_sync_) {
-    EGLSyncKHR fence = InsertFence();
+  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(&GLSurfaceOzoneSurfaceless::FenceRetired,
@@ skipping 47 matching lines @@
       return;
     }
 
     if (ozone_surface_->IsUniversalDisplayLinkDevice())
       glFinish();
 
     ozone_surface_->OnSwapBuffersAsync(frame->callback);
   }
 }
 
-EGLSyncKHR GLSurfaceOzoneSurfaceless::InsertFence() {
+EGLSyncKHR GLSurfaceOzoneSurfaceless::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, attrib_list);
+  return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR,
+                          implicit ? attrib_list : NULL);
 }
 
 void GLSurfaceOzoneSurfaceless::FenceRetired(EGLSyncKHR fence,
                                              PendingFrame* frame) {
   eglDestroySyncKHR(GetDisplay(), fence);
   frame->ready = true;
   SubmitFrame();
 }
 
 void GLSurfaceOzoneSurfaceless::SwapCompleted(
@@ skipping 228 matching lines @@
       ui::OzonePlatform::GetInstance()
           ->GetSurfaceFactoryOzone()
           ->CreateSurfacelessEGLSurfaceForWidget(window);
   if (!surface_ozone)
     return nullptr;
   return InitializeGLSurface(new GLSurfaceOzoneSurfacelessSurfaceImpl(
       std::move(surface_ozone), window));
 }
 
 }  // namespace gl