Update from https://crrev.com/320343

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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/gl_surface.h"
 
 #include "base/bind.h"
+#include "base/callback.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/worker_pool.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_image_linux_dma_buffer.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
 namespace gfx {
 
 namespace {
 
+void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
+  eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
+                       EGL_FOREVER_KHR);
+}
+
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget)
       : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
         ozone_surface_(ozone_surface.Pass()),
         widget_(widget) {}
 
   bool Initialize() override {
@@ skipping 66 matching lines @@
 };
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
   GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             AcceleratedWidget widget)
       : SurfacelessEGL(gfx::Size()),
         ozone_surface_(ozone_surface.Pass()),
         widget_(widget),
         has_implicit_external_sync_(
-            HasEGLExtension("EGL_ARM_implicit_external_sync")) {}
+            HasEGLExtension("EGL_ARM_implicit_external_sync")),
+        last_swap_buffers_result_(true),
+        weak_factory_(this) {}
 
   bool Initialize() override {
     if (!SurfacelessEGL::Initialize())
       return false;
     vsync_provider_ = ozone_surface_->CreateVSyncProvider();
     if (!vsync_provider_)
       return false;
     return true;
   }
   bool Resize(const gfx::Size& size) override {
     if (!ozone_surface_->ResizeNativeWindow(size))
       return false;
 
     return SurfacelessEGL::Resize(size);
   }
   bool SwapBuffers() override {
-    if (!Flush())
-      return false;
+    glFlush();
+    // 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 (!fence)
+        return false;
+
+      EGLDisplay display = GetDisplay();
+      WaitForFence(display, fence);
+      eglDestroySyncKHR(display, fence);
+    } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) {
+      glFinish();
+    }
+
     return ozone_surface_->OnSwapBuffers();
   }
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
   bool IsOffscreen() override { return false; }
   VSyncProvider* GetVSyncProvider() override { return vsync_provider_.get(); }
   bool SupportsPostSubBuffer() override { return true; }
   bool PostSubBuffer(int x, int y, int width, int height) override {
     // The actual sub buffer handling is handled at higher layers.
     SwapBuffers();
     return true;
   }
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override {
-    if (!Flush())
-      return false;
+    glFlush();
+    // TODO: the following should be replaced by a per surface flush as it gets
+    // implemented in GL drivers.
+    if (has_implicit_external_sync_) {
+      // If last swap failed, don't try to schedule new ones.
+      if (!last_swap_buffers_result_) {
+        last_swap_buffers_result_ = true;
+        return false;
+      }
+
+      EGLSyncKHR fence = InsertFence();
+      if (!fence)
+        return false;
+
+      base::Closure fence_wait_task =
+          base::Bind(&WaitForFence, GetDisplay(), fence);
+
+      base::Closure fence_retired_callback =
+          base::Bind(&GLSurfaceOzoneSurfaceless::FenceRetired,
+                     weak_factory_.GetWeakPtr(), fence, callback);
+
+      base::WorkerPool::PostTaskAndReply(FROM_HERE, fence_wait_task,
+                                         fence_retired_callback, false);
+      return true;
+    } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) {
+      glFinish();
+    }
     return ozone_surface_->OnSwapBuffersAsync(callback);
   }
   bool PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override {
     return SwapBuffersAsync(callback);
   }
 
  protected:
   ~GLSurfaceOzoneSurfaceless() override {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
 
-  bool Flush() {
-    glFlush();
-    // TODO: crbug.com/462360 the following should be replaced by a per surface
-    // flush as it gets implemented in GL drivers.
-    if (has_implicit_external_sync_) {
-      const EGLint attrib_list[] = {
-          EGL_SYNC_CONDITION_KHR,
-          EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
-          EGL_NONE};
-      EGLSyncKHR fence =
-          eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, attrib_list);
-      if (fence) {
-        // TODO(dbehr): piman@ suggests we could improve here by moving
-        // following wait to right before drmModePageFlip crbug.com/456417.
-        eglClientWaitSyncKHR(GetDisplay(), fence,
-                             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
-        eglDestroySyncKHR(GetDisplay(), fence);
-      } else {
-        return false;
-      }
-    } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) {
-      glFinish();
-    }
-    return true;
+  EGLSyncKHR InsertFence() {
+    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);
+  }
+
+  void FenceRetired(EGLSyncKHR fence, const SwapCompletionCallback& callback) {
+    eglDestroySyncKHR(GetDisplay(), fence);
+    last_swap_buffers_result_ = ozone_surface_->OnSwapBuffersAsync(callback);
   }
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
   scoped_ptr<VSyncProvider> vsync_provider_;
   bool has_implicit_external_sync_;
+  bool last_swap_buffers_result_;
+
+  base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
 
 // This provides surface-like semantics implemented through surfaceless.
 // A framebuffer is bound automatically.
 class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
     : public GLSurfaceOzoneSurfaceless {
  public:
   GLSurfaceOzoneSurfacelessSurfaceImpl(
       scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
@@ skipping 252 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx